Abstract pref storage from net::SdchOwner

net/sdch/sdch_owner.cc

 // 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 "net/sdch/sdch_owner.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/prefs/persistent_pref_store.h"
-#include "base/prefs/value_map_pref_store.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_net_log_params.h"
 
 namespace net {
 
 namespace {
 
-enum PersistenceFailureReason {
-  // File didn't exist; is being created.
-  PERSISTENCE_FAILURE_REASON_NO_FILE = 1,
-
-  // Error reading in information, but should be able to write.
-  PERSISTENCE_FAILURE_REASON_READ_FAILED = 2,
-
-  // Error leading to abort on attempted persistence.
-  PERSISTENCE_FAILURE_REASON_WRITE_FAILED = 3,
-
-  PERSISTENCE_FAILURE_REASON_MAX = 4
-};
-
 // Dictionaries that haven't been touched in 24 hours may be evicted
 // to make room for new dictionaries.
 const int kFreshnessLifetimeHours = 24;
 
 // Dictionaries that have never been used only stay fresh for one hour.
 const int kNeverUsedFreshnessLifetimeHours = 1;
 
-void RecordPersistenceFailure(PersistenceFailureReason failure_reason) {
-  UMA_HISTOGRAM_ENUMERATION("Sdch3.PersistenceFailureReason", failure_reason,
-                            PERSISTENCE_FAILURE_REASON_MAX);
+void RecordPersistenceFailure(
+    SdchOwner::PrefStorage::ReadError failure_reason) {
+  UMA_HISTOGRAM_ENUMERATION(
+      "Sdch3.PersistenceFailureReason", failure_reason,
+      SdchOwner::PrefStorage::PERSISTENCE_FAILURE_REASON_MAX);
 }
 
 // Schema specifications and access routines.
 
 // The persistent prefs store is conceptually shared with any other network
 // stack systems that want to persist data over browser restarts, and so
 // use of it must be namespace restricted.
 // Schema:
-//      pref_store_->GetValue(kPreferenceName) -> Dictionary {
+//      pref_store_->GetValue() -> Dictionary {
 //          'version' -> 2 [int]
 //          'dictionaries' -> Dictionary {
 //              server_hash -> {
 //                  'url' -> URL [string]
 //                  'last_used' -> seconds since unix epoch [double]
 //                  'created_time' -> seconds since unix epoch [double]
 //                  'use_count' -> use count [int]
 //                  'size' -> size [int]
 //          }
 //      }
-const char kPreferenceName[] = "SDCH";
 const char kVersionKey[] = "version";
 const char kDictionariesKey[] = "dictionaries";
 const char kDictionaryUrlKey[] = "url";
 const char kDictionaryLastUsedKey[] = "last_used";
 const char kDictionaryCreatedTimeKey[] = "created_time";
 const char kDictionaryUseCountKey[] = "use_count";
 const char kDictionarySizeKey[] = "size";
 
 const int kVersion = 2;
 
+// A simple implementation of pref storage that just stores the value in
+// memory.
+class ValueMapPrefStorage : public SdchOwner::PrefStorage {
+ public:
+  ValueMapPrefStorage() {}
+  ~ValueMapPrefStorage() override {}
+
+  ReadError GetReadError() const override { return PERSISTENCE_FAILURE_NONE; }
+
+  bool GetValue(const base::DictionaryValue** result) const override {
+    *result = &storage_;
+    return true;
+  }
+  bool GetMutableValue(base::DictionaryValue** result) override {
+    *result = &storage_;
+    return true;
+  }
+  void SetValue(scoped_ptr<base::DictionaryValue> value) override {
+    storage_.Clear();
+    storage_.MergeDictionary(value.get());
+  }
+
+  void ReportValueChanged() override {}
+
+  // This storage class requires no special initialization.
+  bool IsInitializationComplete() override { return true; }
+  void StartObservingInit(SdchOwner* observer) override {}
+  void StopObservingInit() override {}
+
+ private:
+  base::DictionaryValue storage_;
+
+  DISALLOW_COPY_AND_ASSIGN(ValueMapPrefStorage);
+};
+
 // This function returns store[kPreferenceName/kDictionariesKey].  The caller
 // is responsible for making sure any needed calls to
 // |store->ReportValueChanged()| occur.
 base::DictionaryValue* GetPersistentStoreDictionaryMap(
-    WriteablePrefStore* store) {
-  base::Value* result = nullptr;
-  bool success = store->GetMutableValue(kPreferenceName, &result);
+    SdchOwner::PrefStorage* store) {
+  base::DictionaryValue* preference_dictionary = nullptr;
+  bool success = store->GetMutableValue(&preference_dictionary);
   DCHECK(success);
 
-  base::DictionaryValue* preference_dictionary = nullptr;
-  success = result->GetAsDictionary(&preference_dictionary);
-  DCHECK(success);
-  DCHECK(preference_dictionary);
-
   base::DictionaryValue* dictionary_list_dictionary = nullptr;
   success = preference_dictionary->GetDictionary(kDictionariesKey,
                                                  &dictionary_list_dictionary);
   DCHECK(success);
   DCHECK(dictionary_list_dictionary);
 
   return dictionary_list_dictionary;
 }
 
 // This function initializes a pref store with an empty version of the
 // above schema, removing anything previously in the store under
 // kPreferenceName.
-void InitializePrefStore(WriteablePrefStore* store) {
+void InitializePrefStore(SdchOwner::PrefStorage* store) {
   scoped_ptr<base::DictionaryValue> empty_store(new base::DictionaryValue);
   empty_store->SetInteger(kVersionKey, kVersion);
   empty_store->Set(kDictionariesKey,
                    make_scoped_ptr(new base::DictionaryValue));
-  store->SetValue(kPreferenceName, std::move(empty_store),
-                  WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  store->SetValue(std::move(empty_store));
 }
 
 // A class to allow iteration over all dictionaries in the pref store, and
 // easy lookup of the information associated with those dictionaries.
 // Note that this is an "Iterator" in the same sense (and for the same
 // reasons) that base::Dictionary::Iterator is an iterator--it allows
 // iterating over all the dictionaries in the preference store, but it
 // does not allow use as an STL iterator because the container it
 // is iterating over does not export begin()/end() methods. This iterator can
 // only be safely used on sanitized pref stores that are known to conform to the
 // pref store schema.
 class DictionaryPreferenceIterator {
  public:
-  explicit DictionaryPreferenceIterator(WriteablePrefStore* pref_store);
+  explicit DictionaryPreferenceIterator(SdchOwner::PrefStorage* pref_store);
 
   bool IsAtEnd() const;
   void Advance();
 
   const std::string& server_hash() const { return server_hash_; }
   const GURL& url() const { return url_; }
   base::Time last_used() const { return last_used_; }
   base::Time created_time() const { return created_time_; }
   int use_count() const { return use_count_; }
   int size() const { return size_; }
 
  private:
   // Load Dictionary silently skipping any that are malformed.
   void LoadNextDictionary();
   // Try to load Dictionary from current iterator's position. Returns true if
   // succeeded.
   bool TryLoadDictionary();
 
   std::string server_hash_;
   GURL url_;
   base::Time last_used_;
   base::Time created_time_;
   int use_count_;
   int size_;
 
   base::DictionaryValue::Iterator dictionary_iterator_;
 };
 
 DictionaryPreferenceIterator::DictionaryPreferenceIterator(
-    WriteablePrefStore* pref_store)
+    SdchOwner::PrefStorage* pref_store)
     : use_count_(0),
       size_(0),
       dictionary_iterator_(*GetPersistentStoreDictionaryMap(pref_store)) {
   LoadNextDictionary();
 }
 
 bool DictionaryPreferenceIterator::IsAtEnd() const {
   return dictionary_iterator_.IsAtEnd();
 }
 
@@ skipping 42 matching lines @@
 
   double created_time_seconds = 0;
   success = dict->GetDouble(kDictionaryCreatedTimeKey, &created_time_seconds);
   if (!success)
     return false;
   created_time_ = base::Time::FromDoubleT(created_time_seconds);
 
   return true;
 }
 
-// Triggers a ReportValueChanged() on the specified WriteablePrefStore
-// when the object goes out of scope.
+// Triggers a ReportValueChanged() when the object goes out of scope.
 class ScopedPrefNotifier {
  public:
   // Caller must guarantee lifetime of |*pref_store| exceeds the
   // lifetime of this object.
-  ScopedPrefNotifier(WriteablePrefStore* pref_store)
-      : pref_store_(pref_store) {}
-  ~ScopedPrefNotifier() {
-    pref_store_->ReportValueChanged(
-        kPreferenceName, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  ScopedPrefNotifier(SdchOwner::PrefStorage* pref_store)
+      : pref_store_(pref_store) {
+    DCHECK(pref_store);
   }
+  ~ScopedPrefNotifier() { pref_store_->ReportValueChanged(); }
 
  private:
-  WriteablePrefStore* pref_store_;
+  SdchOwner::PrefStorage* pref_store_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedPrefNotifier);
 };
 
 }  // namespace
 
 // Adjust SDCH limits downwards for mobile.
 #if defined(OS_ANDROID) || defined(OS_IOS)
 // static
 const size_t SdchOwner::kMaxTotalDictionarySize = 2 * 500 * 1000;
 #else
 // static
 const size_t SdchOwner::kMaxTotalDictionarySize = 20 * 1000 * 1000;
 #endif
 
+SdchOwner::PrefStorage::~PrefStorage() {}
+
 // Somewhat arbitrary, but we assume a dictionary smaller than
 // 50K isn't going to do anyone any good.  Note that this still doesn't
 // prevent download and addition unless there is less than this
 // amount of space available in storage.
 const size_t SdchOwner::kMinSpaceForDictionaryFetch = 50 * 1000;
 
 void SdchOwner::RecordDictionaryFate(enum DictionaryFate fate) {
   UMA_HISTOGRAM_ENUMERATION("Sdch3.DictionaryFate", fate, DICTIONARY_FATE_MAX);
 }
 
@@ skipping 22 matching lines @@
       total_dictionary_bytes_(0),
       clock_(new base::DefaultClock),
       max_total_dictionary_size_(kMaxTotalDictionarySize),
       min_space_for_dictionary_fetch_(kMinSpaceForDictionaryFetch),
       memory_pressure_listener_(
           base::Bind(&SdchOwner::OnMemoryPressure,
                      // Because |memory_pressure_listener_| is owned by
                      // SdchOwner, the SdchOwner object will be available
                      // for the lifetime of |memory_pressure_listener_|.
                      base::Unretained(this))),
-      in_memory_pref_store_(new ValueMapPrefStore()),
+      in_memory_pref_store_(new ValueMapPrefStorage()),
       external_pref_store_(nullptr),
       pref_store_(in_memory_pref_store_.get()),
       creation_time_(clock_->Now()) {
   manager_->AddObserver(this);
   InitializePrefStore(pref_store_);
 }
 
 SdchOwner::~SdchOwner() {
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     int new_uses = it.use_count() - use_counts_at_load_[it.server_hash()];
     DictionaryFate fate = IsPersistingDictionaries() ?
                           DICTIONARY_FATE_UNLOAD_FOR_DESTRUCTION :
                           DICTIONARY_FATE_EVICT_FOR_DESTRUCTION;
     RecordDictionaryEvictionOrUnload(it.server_hash(), it.size(), new_uses,
                                      fate);
   }
   manager_->RemoveObserver(this);
 
   // This object only observes the external store during loading,
   // i.e. before it's made the default preferences store.
-  if (external_pref_store_)
-    external_pref_store_->RemoveObserver(this);
+  if (external_pref_store_ && pref_store_ != external_pref_store_.get())
+    external_pref_store_->StopObservingInit();
 
   int64_t object_lifetime = (clock_->Now() - creation_time_).InMilliseconds();
   for (const auto& val : consumed_byte_seconds_) {
     if (object_lifetime > 0) {
       // Objects that are created and immediately destroyed don't add any memory
       // pressure over time (and also cause a crash here).
       UMA_HISTOGRAM_MEMORY_KB("Sdch3.TimeWeightedMemoryUse",
                               val / object_lifetime);
     }
   }
-
 }
 
-void SdchOwner::EnablePersistentStorage(PersistentPrefStore* pref_store) {
+void SdchOwner::EnablePersistentStorage(scoped_ptr<PrefStorage> pref_store) {
   DCHECK(!external_pref_store_);
-  external_pref_store_ = pref_store;
-  external_pref_store_->AddObserver(this);
+  DCHECK(pref_store);
+  external_pref_store_ = std::move(pref_store);
+  external_pref_store_->StartObservingInit(this);
 
   if (external_pref_store_->IsInitializationComplete())
-    OnInitializationCompleted(true);
+    OnPrefStorageInitializationComplete(true);
 }
 
 void SdchOwner::SetMaxTotalDictionarySize(size_t max_total_dictionary_size) {
   max_total_dictionary_size_ = max_total_dictionary_size;
 }
 
 void SdchOwner::SetMinSpaceForDictionaryFetch(
     size_t min_space_for_dictionary_fetch) {
   min_space_for_dictionary_fetch_ = min_space_for_dictionary_fetch;
 }
@@ skipping 230 matching lines @@
                  base::Unretained(this), base::Time(), base::Time::Now(), 0));
 }
 
 void SdchOwner::OnClearDictionaries() {
   total_dictionary_bytes_ = 0;
   fetcher_->Cancel();
 
   InitializePrefStore(pref_store_);
 }
 
-void SdchOwner::OnPrefValueChanged(const std::string& key) {
-}
-
-void SdchOwner::OnInitializationCompleted(bool succeeded) {
-  PersistentPrefStore::PrefReadError error =
-      external_pref_store_->GetReadError();
+void SdchOwner::OnPrefStorageInitializationComplete(bool succeeded) {
+  PrefStorage::ReadError error = external_pref_store_->GetReadError();
   // Errors on load are self-correcting; if dictionaries were not
   // persisted from the last instance of the browser, they will be
   // faulted in by user action over time.  However, if a load error
   // means that the dictionary information won't be able to be persisted,
   // the in memory pref store is left in place.
   if (!succeeded) {
     // Failure means a write failed, since read failures are recoverable.
-    DCHECK_NE(
-        error,
-        PersistentPrefStore::PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE);
-    DCHECK_NE(error,
-              PersistentPrefStore::PREF_READ_ERROR_MAX_ENUM);
-
-    LOG(ERROR) << "Pref store write failed: " << error;
-    external_pref_store_->RemoveObserver(this);
+    external_pref_store_->StopObservingInit();
     external_pref_store_ = nullptr;
-    RecordPersistenceFailure(PERSISTENCE_FAILURE_REASON_WRITE_FAILED);
+    RecordPersistenceFailure(
+        PrefStorage::PERSISTENCE_FAILURE_REASON_WRITE_FAILED);
     return;
   }
-  switch (external_pref_store_->GetReadError()) {
-    case PersistentPrefStore::PREF_READ_ERROR_NONE:
-        break;
 
-    case PersistentPrefStore::PREF_READ_ERROR_NO_FILE:
-      // First time reading; the file will be created.
-      RecordPersistenceFailure(PERSISTENCE_FAILURE_REASON_NO_FILE);
-      break;
-
-    case PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE:
-    case PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE:
-    case PersistentPrefStore::PREF_READ_ERROR_FILE_OTHER:
-    case PersistentPrefStore::PREF_READ_ERROR_FILE_LOCKED:
-    case PersistentPrefStore::PREF_READ_ERROR_JSON_REPEAT:
-      RecordPersistenceFailure(PERSISTENCE_FAILURE_REASON_READ_FAILED);
-      break;
-
-    case PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED:
-    case PersistentPrefStore::PREF_READ_ERROR_FILE_NOT_SPECIFIED:
-    case PersistentPrefStore::PREF_READ_ERROR_ASYNCHRONOUS_TASK_INCOMPLETE:
-    case PersistentPrefStore::PREF_READ_ERROR_MAX_ENUM:
-      // Shouldn't ever happen. ACCESS_DENIED and FILE_NOT_SPECIFIED should
-      // imply !succeeded, and TASK_INCOMPLETE should never be delivered.
-      NOTREACHED();
-      break;
-  }
-
+  if (error != PrefStorage::PERSISTENCE_FAILURE_NONE)
+    RecordPersistenceFailure(error);
 
   // Load in what was stored before chrome exited previously.
-  const base::Value* sdch_persistence_value = nullptr;
   const base::DictionaryValue* sdch_persistence_dictionary = nullptr;
 
   // The GetPersistentStore() routine above assumes data formatted
   // according to the schema described at the top of this file.  Since
   // this data comes from disk, to avoid disk corruption resulting in
   // persistent chrome errors this code avoids those assupmtions.
-  if (external_pref_store_->GetValue(kPreferenceName,
-                                     &sdch_persistence_value) &&
-      sdch_persistence_value->GetAsDictionary(&sdch_persistence_dictionary)) {
+  if (external_pref_store_->GetValue(&sdch_persistence_dictionary))
     SchedulePersistedDictionaryLoads(*sdch_persistence_dictionary);
-  }
 
   // Reset the persistent store and update it with the accumulated
   // information from the local store.
-  InitializePrefStore(external_pref_store_);
+  InitializePrefStore(external_pref_store_.get());
 
-  ScopedPrefNotifier scoped_pref_notifier(external_pref_store_);
-  GetPersistentStoreDictionaryMap(external_pref_store_)
+  ScopedPrefNotifier scoped_pref_notifier(external_pref_store_.get());
+  GetPersistentStoreDictionaryMap(external_pref_store_.get())
       ->Swap(GetPersistentStoreDictionaryMap(in_memory_pref_store_.get()));
 
   // This object can stop waiting on (i.e. observing) the external preference
   // store and switch over to using it as the primary preference store.
-  pref_store_ = external_pref_store_;
-  external_pref_store_->RemoveObserver(this);
-  external_pref_store_ = nullptr;
+  pref_store_ = external_pref_store_.get();
+  external_pref_store_->StopObservingInit();
   in_memory_pref_store_ = nullptr;
 }
 
 void SdchOwner::SetClockForTesting(scoped_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 int SdchOwner::GetDictionaryCountForTesting() const {
   int count = 0;
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
@@ skipping 86 matching lines @@
   }
 
   return true;
 }
 
 bool SdchOwner::IsPersistingDictionaries() const {
   return in_memory_pref_store_.get() != nullptr;
 }
 
 }  // namespace net