blob: 769d0b4be7cccf05571a2bfa5b172048cbd6d887 [file] [log] [blame]
// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "cobalt/storage/savegame.h"
#include <algorithm>
#include "base/file_util.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/optional.h"
#include "base/path_service.h"
#include "starboard/storage.h"
#include "starboard/user.h"
namespace cobalt {
namespace storage {
namespace {
// An arbitrary max size for the save game file so that, for example, a corrupt
// filesystem cannot cause us to allocate a fatally large memory buffer.
size_t kMaxSaveGameSizeBytes = 4 * 1024 * 1024;
bool ReadRecord(Savegame::ByteVector* bytes_ptr, size_t max_to_read,
const scoped_ptr<starboard::StorageRecord>& record) {
if (!record->IsValid()) {
DLOG(WARNING) << __FUNCTION__ << ": Invalid StorageRecord";
return false;
}
int64_t size = record->GetSize();
if (size < 0) {
DLOG(WARNING) << "StorageRecord::GetSize failed";
return false;
}
if (static_cast<size_t>(size) > max_to_read) {
DLOG(WARNING) << "Savegame larger than max allowed size";
return false;
}
Savegame::ByteVector& bytes = *bytes_ptr;
bytes.resize(static_cast<size_t>(size));
if (bytes.empty()) {
return true;
}
int64_t bytes_read =
record->Read(reinterpret_cast<char*>(bytes.data()), size);
bytes.resize(
static_cast<size_t>(std::max(static_cast<int64_t>(0), bytes_read)));
return bytes_read == size;
}
bool WriteRecord(const scoped_ptr<starboard::StorageRecord>& record,
const Savegame::ByteVector& bytes) {
int64_t byte_count = static_cast<int64_t>(bytes.size());
return record->Write(reinterpret_cast<const char*>(bytes.data()), byte_count);
}
scoped_ptr<starboard::StorageRecord> CreateRecord(
const base::optional<std::string>& id) {
#if SB_API_VERSION >= 6
if (id) {
return make_scoped_ptr(new starboard::StorageRecord(id->c_str()));
}
#else // SB_API_VERSION >= 6
UNREFERENCED_PARAMETER(id);
#endif // SB_API_VERSION >= 6
return make_scoped_ptr(new starboard::StorageRecord());
}
bool EnsureRecord(scoped_ptr<starboard::StorageRecord>* record,
const base::optional<std::string>& id) {
if (!(*record) || !(*record)->IsValid()) {
// Might have been deleted, so we'll create a new one.
(*record) = CreateRecord(id);
}
if (!(*record)->IsValid()) {
DLOG(WARNING) << __FUNCTION__ << ": Invalid StorageRecord: Signed in?";
return false;
}
return true;
}
// Savegame implementation that writes to the Starboard Storage API.
class SavegameStarboard : public Savegame {
public:
explicit SavegameStarboard(const Options& options);
~SavegameStarboard() OVERRIDE;
bool PlatformRead(ByteVector* bytes, size_t max_to_read) OVERRIDE;
bool PlatformWrite(const ByteVector& bytes) OVERRIDE;
bool PlatformDelete() OVERRIDE;
private:
bool MigrateFromFallback();
scoped_ptr<starboard::StorageRecord> record_;
};
SavegameStarboard::SavegameStarboard(const Options& options)
: Savegame(options) {
EnsureRecord(&record_, options_.id);
}
SavegameStarboard::~SavegameStarboard() {
if (options_.delete_on_destruction) {
Delete();
}
}
bool SavegameStarboard::PlatformRead(ByteVector* bytes_ptr,
size_t max_to_read) {
bool success = ReadRecord(bytes_ptr, max_to_read, record_);
if (success && !bytes_ptr->empty()) {
return true;
}
if (!options_.fallback_to_default_id) {
return false;
}
if (!MigrateFromFallback()) {
DLOG(WARNING) << __FUNCTION__ << ": Migration Failed";
return false;
}
// Now read the migrated data.
return ReadRecord(bytes_ptr, max_to_read, record_);
}
bool SavegameStarboard::PlatformWrite(const ByteVector& bytes) {
if (!EnsureRecord(&record_, options_.id)) {
return false;
}
return WriteRecord(record_, bytes);
}
bool SavegameStarboard::PlatformDelete() {
if (!record_->IsValid()) {
DLOG(WARNING) << __FUNCTION__ << ": Invalid StorageRecord";
return false;
}
return record_->Delete();
}
bool SavegameStarboard::MigrateFromFallback() {
ByteVector buffer;
if (!EnsureRecord(&record_, options_.id)) {
DLOG(WARNING) << __FUNCTION__ << ": "
<< "Failed to ensure record for ID: " << options_.id;
return false;
}
scoped_ptr<starboard::StorageRecord> fallback_record;
if (!EnsureRecord(&fallback_record, base::nullopt)) {
DLOG(WARNING) << __FUNCTION__ << ": "
<< "Failed to open default record.";
return false;
}
if (!ReadRecord(&buffer, kMaxSaveGameSizeBytes, fallback_record)) {
DLOG(WARNING) << __FUNCTION__ << ": "
<< "Failed to read default record.";
return false;
}
if (buffer.size() == 0) {
// We migrated nothing successfully.
return true;
}
if (!WriteRecord(record_, buffer)) {
DLOG(WARNING) << __FUNCTION__ << ": "
<< "Failed to write record for ID: " << options_.id;
return false;
}
// Flush the migrated record by closing and reopening it.
record_.reset();
if (!EnsureRecord(&record_, options_.id)) {
return false;
}
// Now cleanup the fallback record.
fallback_record->Delete();
return true;
}
} // namespace
// static
scoped_ptr<Savegame> Savegame::Create(const Options& options) {
return make_scoped_ptr(new SavegameStarboard(options)).PassAs<Savegame>();
}
} // namespace storage
} // namespace cobalt