resource_metadata_storage.cc | Explore in Territory

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "components/drive/resource_metadata_storage.h"

#include <stddef.h>

#include <map>
#include <set>
#include <unordered_map>
#include <utility>

#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/task/sequenced_task_runner.h"
#include "base/threading/scoped_blocking_call.h"
#include "components/drive/drive.pb.h"
#include "components/drive/drive_api_util.h"
#include "components/drive/file_system_core_util.h"
#include "third_party/leveldatabase/env_chromium.h"
#include "third_party/leveldatabase/leveldb_chrome.h"
#include "third_party/leveldatabase/src/include/leveldb/db.h"
#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"

namespace drive {
namespace internal {

namespace {

// Enum to describe DB initialization status.
enum DBInitStatus { … };

// The name of the DB which stores the metadata.
const base::FilePath::CharType kResourceMapDBName[] = …);

// The name of the DB which couldn't be opened, but is preserved just in case.
const base::FilePath::CharType kPreservedResourceMapDBName[] = …);

// The name of the DB which couldn't be opened, and was replaced with a new one.
const base::FilePath::CharType kTrashedResourceMapDBName[] = …);

// Meant to be a character which never happen to be in real IDs.
const char kDBKeyDelimeter = …;

// String used as a suffix of a key for a cache entry.
const char kCacheEntryKeySuffix[] = …;

// String used as a prefix of a key for a resource-ID-to-local-ID entry.
const char kIdEntryKeyPrefix[] = …;

// Returns a string to be used as the key for the header.
std::string GetHeaderDBKey() { … }

// Returns true if |key| is a key for a child entry.
bool IsChildEntryKey(const leveldb::Slice& key) { … }

// Returns true if |key| is a key for a cache entry.
bool IsCacheEntryKey(const leveldb::Slice& key) { … }

// Returns ID extracted from a cache entry key.
std::string GetIdFromCacheEntryKey(const leveldb::Slice& key) { … }

// Returns a string to be used as a key for a resource-ID-to-local-ID entry.
std::string GetIdEntryKey(const std::string& resource_id) { … }

// Returns true if |key| is a key for a resource-ID-to-local-ID entry.
bool IsIdEntryKey(const leveldb::Slice& key) { … }

// Returns the resource ID extracted from a resource-ID-to-local-ID entry key.
std::string GetResourceIdFromIdEntryKey(const leveldb::Slice& key) { … }

// Converts leveldb::Status to DBInitStatus.
DBInitStatus LevelDBStatusToDBInitStatus(const leveldb::Status& status) { … }

// Converts leveldb::Status to FileError.
FileError LevelDBStatusToFileError(const leveldb::Status& status) { … }

ResourceMetadataHeader GetDefaultHeaderEntry() { … }

bool MoveIfPossible(const base::FilePath& from, const base::FilePath& to) { … }

bool UpgradeOldDBVersions6To10(leveldb::DB* resource_map) { … }

bool UpgradeOldDBVersion11(leveldb::DB* resource_map) { … }

bool UpgradeOldDBVersion12(leveldb::DB* resource_map) { … }

bool UpgradeOldDBVersion13(leveldb::DB* resource_map) { … }

bool UpgradeOldDBVersion14(leveldb::DB* resource_map) { … }

bool UpgradeOldDBVersion15(leveldb::DB* resource_map) { … }

bool UpgradeOldDBVersions16To18(leveldb::DB* resource_map) { … }

}  // namespace

ResourceMetadataStorage::Iterator::Iterator(
    std::unique_ptr<leveldb::Iterator> it)
    : … { … }

ResourceMetadataStorage::Iterator::~Iterator() { … }

bool ResourceMetadataStorage::Iterator::IsAtEnd() const { … }

std::string ResourceMetadataStorage::Iterator::GetID() const { … }

const ResourceEntry& ResourceMetadataStorage::Iterator::GetValue() const { … }

void ResourceMetadataStorage::Iterator::Advance() { … }

bool ResourceMetadataStorage::Iterator::HasError() const { … }

// static
bool ResourceMetadataStorage::UpgradeOldDB(
    const base::FilePath& directory_path) { … }

ResourceMetadataStorage::ResourceMetadataStorage(
    const base::FilePath& directory_path,
    base::SequencedTaskRunner* blocking_task_runner)
    : … { … }

bool ResourceMetadataStorage::Initialize() { … }

void ResourceMetadataStorage::Destroy() { … }

void ResourceMetadataStorage::RecoverCacheInfoFromTrashedResourceMap(
    RecoveredCacheInfoMap* out_info) { … }

FileError ResourceMetadataStorage::SetLargestChangestamp(
    int64_t largest_changestamp) { … }

FileError ResourceMetadataStorage::GetLargestChangestamp(
    int64_t* largest_changestamp) { … }

FileError ResourceMetadataStorage::GetStartPageToken(
    std::string* start_page_token) { … }

FileError ResourceMetadataStorage::SetStartPageToken(
    const std::string& start_page_token) { … }

FileError ResourceMetadataStorage::PutEntry(const ResourceEntry& entry) { … }

FileError ResourceMetadataStorage::GetEntry(const std::string& id,
                                            ResourceEntry* out_entry) { … }

FileError ResourceMetadataStorage::RemoveEntry(const std::string& id) { … }

std::unique_ptr<ResourceMetadataStorage::Iterator>
ResourceMetadataStorage::GetIterator() { … }

FileError ResourceMetadataStorage::GetChild(const std::string& parent_id,
                                            const std::string& child_name,
                                            std::string* child_id) const { … }

FileError ResourceMetadataStorage::GetChildren(
    const std::string& parent_id,
    std::vector<std::string>* children) const { … }

FileError ResourceMetadataStorage::GetIdByResourceId(
    const std::string& resource_id,
    std::string* out_id) const { … }

ResourceMetadataStorage::RecoveredCacheInfo::RecoveredCacheInfo()
    : … { … }

ResourceMetadataStorage::RecoveredCacheInfo::~RecoveredCacheInfo() = default;

ResourceMetadataStorage::~ResourceMetadataStorage() { … }

void ResourceMetadataStorage::DestroyOnBlockingPool() { … }

// static
std::string ResourceMetadataStorage::GetChildEntryKey(
    const std::string& parent_id,
    const std::string& child_name) { … }

FileError ResourceMetadataStorage::PutHeader(
    const ResourceMetadataHeader& header) { … }

FileError ResourceMetadataStorage::GetHeader(
    ResourceMetadataHeader* header) const { … }

bool ResourceMetadataStorage::CheckValidity() { … }

}  // namespace internal
}  // namespace drive
chromium/components/drive/resource_metadata_storage.cc
