blob: 35260a717ba4c982cb60056419e5f4978e95fe57 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stddef.h>
#include <stdint.h>
#include <map>
#include <string>
#include "base/macros.h"
#include "base/memory/memory_coordinator_client.h"
#include "base/memory/memory_pressure_listener.h"
#include "base/memory/ref_counted.h"
#include "net/base/net_export.h"
#include "net/base/sdch_observer.h"
#include "net/url_request/sdch_dictionary_fetcher.h"
class GURL;
namespace base {
class Clock;
namespace net {
class NetLogWithSource;
class SdchManager;
class URLRequestContext;
// This class owns the SDCH objects not owned as part of URLRequestContext, and
// exposes interface for setting SDCH policy. It should be instantiated by
// the net/ embedder.
// TODO(rdsmith): Implement dictionary prioritization.
class NET_EXPORT SdchOwner : public SdchObserver,
public base::MemoryCoordinatorClient {
// Abstact storage interface for storing settings that allows the embedder
// to provide the appropriate storage backend.
class NET_EXPORT PrefStorage {
// Possible values returned by GetReadError. This is a subset of the error
// values of Chromium's pref storage that we care about.
// DO NOT CHANGE VALUES. This is logged persistently in a histogram.
enum ReadError {
// File didn't exist; is being created.
// Error reading in information, but should be able to write.
// Error leading to abort on attempted persistence.
// Anything else.
// See RecordPersistenceFailure for UMA logging of this value if
// adding a value here.
virtual ~PrefStorage();
// Returns the read error if any. Valid to be called after initialization
// is complete (see IsInitializationComplete).
virtual ReadError GetReadError() const = 0;
// Gets or sets the value in the preferences store.
virtual bool GetValue(const base::DictionaryValue** result) const = 0;
virtual bool GetMutableValue(base::DictionaryValue** result) = 0;
virtual void SetValue(std::unique_ptr<base::DictionaryValue> value) = 0;
// Notifies the storage system that a value was changed via mutating the
// result of GetMutableValue().
virtual void ReportValueChanged() = 0;
// Returns true if the store's init is complete. See the Start/Stop
// functions below for observing changes to this value.
virtual bool IsInitializationComplete() = 0;
// Starts and stops observing preferences storage init. There will only
// be one observer active at a time. The store should call
// OnPrefStorageInitializationComplete() when it transitions to initialized
// and there is an observer active. See also IsInitializationComplete().
virtual void StartObservingInit(SdchOwner* observer) = 0;
virtual void StopObservingInit() = 0;
static const size_t kMaxTotalDictionarySize;
static const size_t kMinSpaceForDictionaryFetch;
// Consumer must guarantee that |sdch_manager| and |context| outlive
// this object.
SdchOwner(SdchManager* sdch_manager, URLRequestContext* context);
~SdchOwner() override;
// Enables use of pref persistence. Ownership of the storage will be passed.
// This routine may only be called once per SdchOwner instance.
void EnablePersistentStorage(std::unique_ptr<PrefStorage> pref_store);
// Defaults to kMaxTotalDictionarySize.
void SetMaxTotalDictionarySize(size_t max_total_dictionary_size);
// Defaults to kMinSpaceForDictionaryFetch.
void SetMinSpaceForDictionaryFetch(size_t min_space_for_dictionary_fetch);
// SdchObserver implementation.
void OnDictionaryAdded(const GURL& dictionary_url,
const std::string& server_hash) override;
void OnDictionaryRemoved(const std::string& server_hash) override;
void OnDictionaryUsed(const std::string& server_hash) override;
void OnGetDictionary(const GURL& request_url,
const GURL& dictionary_url) override;
void OnClearDictionaries() override;
// Called by the PrefStorage implementation when initialization is complete.
// See PrefStorage::StartObservingInit().
void OnPrefStorageInitializationComplete(bool succeeded);
// Implementation detail--this is the function callback by the callback passed
// to the fetcher through which the fetcher informs the SdchOwner that it's
// gotten the dictionary. The first two arguments are bound locally.
// Public for testing.
void OnDictionaryFetched(base::Time last_used,
base::Time created_time,
int use_count,
const std::string& dictionary_text,
const GURL& dictionary_url,
const NetLogWithSource& net_log,
bool was_from_cache);
void SetClockForTesting(std::unique_ptr<base::Clock> clock);
// Returns the total number of dictionaries loaded.
int GetDictionaryCountForTesting() const;
// Returns whether this SdchOwner has dictionary from |url| loaded.
bool HasDictionaryFromURLForTesting(const GURL& url) const;
void SetFetcherForTesting(std::unique_ptr<SdchDictionaryFetcher> fetcher);
// For each active dictionary, stores local info.
// Indexed by the server hash of the dictionary.
struct DictionaryInfo {
base::Time last_used;
int use_count;
size_t size;
DictionaryInfo() : use_count(0), size(0) {}
DictionaryInfo(const base::Time& last_used, size_t size)
: last_used(last_used), use_count(0), size(size) {}
DictionaryInfo(const DictionaryInfo& rhs) = default;
DictionaryInfo& operator=(const DictionaryInfo& rhs) = default;
// base::MemoryCoordinatorClient implementation:
void OnPurgeMemory() override;
void OnMemoryPressure(
base::MemoryPressureListener::MemoryPressureLevel level);
// Clears data to save memory usage.
void ClearData();
// Schedule loading of all dictionaries described in |persisted_info|.
// Returns false and does not schedule a load if |persisted_info| has an
// unsupported version or no dictionaries key. Skips any dictionaries that are
// malformed in |persisted_info|.
bool SchedulePersistedDictionaryLoads(
const base::DictionaryValue& persisted_info);
bool IsPersistingDictionaries() const;
enum DictionaryFate {
// A Get-Dictionary header wasn't acted on.
// A fetch was attempted, but failed.
// TODO(rdsmith): Actually record this case.
// A successful fetch was dropped on the floor, no space.
// A successful fetch was refused by the SdchManager.
// A dictionary was successfully added based on
// a Get-Dictionary header in a response.
// A dictionary was evicted by an incoming dict.
// A dictionary was evicted by memory pressure.
// A dictionary was evicted on destruction.
// A dictionary was successfully added based on
// persistence from a previous browser revision.
// A dictionary was unloaded on destruction, but is still present on disk.
void RecordDictionaryFate(DictionaryFate fate);
// Record the lifetime memory use of a specified dictionary, identified by
// server hash.
void RecordDictionaryEvictionOrUnload(
const std::string& server_hash,
size_t size,
int use_count, DictionaryFate fate);
net::SdchManager* manager_;
std::unique_ptr<net::SdchDictionaryFetcher> fetcher_;
size_t total_dictionary_bytes_;
std::unique_ptr<base::Clock> clock_;
size_t max_total_dictionary_size_;
size_t min_space_for_dictionary_fetch_;
base::MemoryPressureListener memory_pressure_listener_;
// Dictionary persistence machinery.
// * |in_memory_pref_store_| is created on construction and used in the
// absence of any call to EnablePersistentStorage().
// * |external_pref_store_| holds the preference store specified by
// EnablePersistentStorage() (if any).
// * The external pref store is initialized asynchronously. During this time,
// both pointers will be value, pref_store_ will point to the in-memory
// one, and this class will be observing the initialization of the external
// store.
// * When the external pref store is initialized, the in-memory version will
// be freed, and pref_store_ will point to the external one.
// * |pref_store_| holds an unowned pointer to the currently
// active pref store (one of the preceding two).
std::unique_ptr<PrefStorage> in_memory_pref_store_;
std::unique_ptr<PrefStorage> external_pref_store_;
PrefStorage* pref_store_;
// The use counts of dictionaries when they were loaded from the persistent
// store, keyed by server hash. These are stored to avoid generating
// misleading ever-increasing use counts for dictionaries that are persisted,
// since the UMA histogram for use counts is only supposed to be since last
// load.
std::map<std::string, int> use_counts_at_load_;
// Load times for loaded dictionaries, keyed by server hash. These are used to
// track the durations that dictionaries are in memory.
std::map<std::string, base::Time> load_times_;
// Byte-seconds consumed by dictionaries that have been unloaded. These are
// stored for later uploading in the SdchOwner destructor.
std::vector<int64_t> consumed_byte_seconds_;
// Creation time for this SdchOwner object, used for reporting temporal memory
// pressure.
base::Time creation_time_;
} // namespace net