session_storage_manager.cc | Explore in Territory

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

#include "extensions/browser/api/storage/session_storage_manager.h"

#include "base/no_destructor.h"
#include "base/trace_event/memory_usage_estimator.h"
#include "components/keyed_service/content/browser_context_dependency_manager.h"
#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
#include "extensions/browser/extension_registry_factory.h"
#include "extensions/browser/extensions_browser_client.h"
#include "extensions/common/api/storage.h"

EstimateMemoryUsage;

namespace extensions {

namespace {

class SessionStorageManagerFactory : public BrowserContextKeyedServiceFactory { … };

SessionStorageManagerFactory::SessionStorageManagerFactory()
    : … { … }

SessionStorageManager* SessionStorageManagerFactory::GetForBrowserContext(
    content::BrowserContext* browser_context) { … }

content::BrowserContext* SessionStorageManagerFactory::GetBrowserContextToUse(
    content::BrowserContext* browser_context) const { … }

KeyedService* SessionStorageManagerFactory::BuildServiceInstanceFor(
    content::BrowserContext* browser_context) const { … }

}  // namespace

// Implementation of SessionValue.
SessionStorageManager::SessionValue::SessionValue(base::Value value,
                                                  size_t size)
    : … { … }

// Implementation of ValueChange.
SessionStorageManager::ValueChange::ValueChange(
    std::string key,
    std::optional<base::Value> old_value,
    base::Value* new_value)
    : … { … }

SessionStorageManager::ValueChange::~ValueChange() = default;

SessionStorageManager::ValueChange::ValueChange(ValueChange&& other) = default;

// Implementation of ExtensionStorage.
SessionStorageManager::ExtensionStorage::ExtensionStorage(size_t quota_bytes)
    : … { … }

SessionStorageManager::ExtensionStorage::~ExtensionStorage() = default;

size_t SessionStorageManager::ExtensionStorage::CalculateUsage(
    std::map<std::string, base::Value> input_values,
    std::map<std::string, std::unique_ptr<SessionValue>>& session_values)
    const { … }

std::map<std::string, const base::Value*>
SessionStorageManager::ExtensionStorage::Get(
    const std::vector<std::string>& keys) const { … }

std::map<std::string, const base::Value*>
SessionStorageManager::ExtensionStorage::GetAll() const { … }

bool SessionStorageManager::ExtensionStorage::Set(
    std::map<std::string, base::Value> input_values,
    std::vector<ValueChange>& changes,
    std::string* error) { … }

void SessionStorageManager::ExtensionStorage::Remove(
    const std::vector<std::string>& keys,
    std::vector<ValueChange>& changes) { … }

void SessionStorageManager::ExtensionStorage::Clear(
    std::vector<ValueChange>& changes) { … }

void SessionStorageManager::ExtensionStorage::Clear() { … }

size_t SessionStorageManager::ExtensionStorage::GetBytesInUse(
    const std::vector<std::string>& keys) const { … }

size_t SessionStorageManager::ExtensionStorage::GetTotalBytesInUse() const { … }

// Implementation of SessionStorageManager.
SessionStorageManager::SessionStorageManager(
    size_t quota_bytes_per_extension,
    content::BrowserContext* browser_context)
    : … { … }

SessionStorageManager::~SessionStorageManager() = default;

// static
SessionStorageManager* SessionStorageManager::GetForBrowserContext(
    content::BrowserContext* browser_context) { … }

// static
BrowserContextKeyedServiceFactory* SessionStorageManager::GetFactory() { … }

const base::Value* SessionStorageManager::Get(const ExtensionId& extension_id,
                                              const std::string& key) const { … }

std::map<std::string, const base::Value*> SessionStorageManager::Get(
    const ExtensionId& extension_id,
    const std::vector<std::string>& keys) const { … }

std::map<std::string, const base::Value*> SessionStorageManager::GetAll(
    const ExtensionId& extension_id) const { … }

bool SessionStorageManager::Set(const ExtensionId& extension_id,
                                std::map<std::string, base::Value> input_values,
                                std::vector<ValueChange>& changes,
                                std::string* error) { … }

void SessionStorageManager::Remove(const ExtensionId& extension_id,
                                   const std::vector<std::string>& keys,
                                   std::vector<ValueChange>& changes) { … }

void SessionStorageManager::Remove(const ExtensionId& extension_id,
                                   const std::string& key,
                                   std::vector<ValueChange>& changes) { … }

void SessionStorageManager::Clear(const ExtensionId& extension_id,
                                  std::vector<ValueChange>& changes) { … }

void SessionStorageManager::Clear(const ExtensionId& extension_id) { … }

size_t SessionStorageManager::GetBytesInUse(const ExtensionId& extension_id,
                                            const std::string& key) const { … }

size_t SessionStorageManager::GetBytesInUse(
    const ExtensionId& extension_id,
    const std::vector<std::string>& keys) const { … }

size_t SessionStorageManager::GetTotalBytesInUse(
    const ExtensionId& extension_id) const { … }

void SessionStorageManager::OnExtensionUnloaded(
    content::BrowserContext* browser_context,
    const Extension* extension,
    UnloadedExtensionReason reason) { … }

}  // namespace extensions
chromium/extensions/browser/api/storage/session_storage_manager.cc
