Abstract pref storage from net::SdchOwner

net/sdch/sdch_owner_unittest.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/location.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
-#include "base/prefs/testing_pref_store.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "net/base/sdch_manager.h"
 #include "net/log/net_log.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace net {
+
 namespace {
 
-bool GetDictionaryForURL(TestingPrefStore* store,
+bool GetDictionaryForURL(SdchOwner::PrefStorage* store,
                          const GURL& url,
                          std::string* hash,
                          base::DictionaryValue** dict) {
-  base::Value* sdch_val = nullptr;
   base::DictionaryValue* sdch_dict = nullptr;
-  if (!store->GetMutableValue("SDCH", &sdch_val))
-    return false;
-  if (!sdch_val->GetAsDictionary(&sdch_dict))
+  if (!store->GetMutableValue(&sdch_dict))
     return false;
 
   base::DictionaryValue* dicts_dict = nullptr;
   if (!sdch_dict->GetDictionary("dictionaries", &dicts_dict))
     return false;
 
   base::DictionaryValue::Iterator it(*dicts_dict);
   while (!it.IsAtEnd()) {
     const base::DictionaryValue* d = nullptr;
     if (!it.value().GetAsDictionary(&d))
       continue;
     std::string dict_url;
     if (d->GetString("url", &dict_url) && dict_url == url.spec()) {
       if (hash)
         *hash = it.key();
       if (dict)
         dicts_dict->GetDictionary(it.key(), dict);
       return true;
     }
     it.Advance();
   }
 
   return false;
 }
 
+// This class supports copying so we can emulate persistent storage.
+class TestPrefStorage : public SdchOwner::PrefStorage {
+ public:
+  explicit TestPrefStorage(bool initialized)
+      : initialized_(initialized), initialization_observer_(nullptr) {}
+  explicit TestPrefStorage(const TestPrefStorage& other)
+      : initialized_(other.initialized_),
+        initialization_observer_(nullptr) {  // Don't copy observer.
+    storage_.MergeDictionary(&other.storage_);
+  }
+
+  ~TestPrefStorage() override {}
+
+  void SetInitialized() {
+    DCHECK(!initialized_);
+    initialized_ = true;
+    if (initialization_observer_)
+      initialization_observer_->OnPrefStorageInitializationComplete(true);
+  }
+
+  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 initialized_; }
+  void StartObservingInit(SdchOwner* observer) override {
+    DCHECK(!initialization_observer_);
+    initialization_observer_ = observer;
+  }
+  void StopObservingInit() override { initialization_observer_ = nullptr; }
+
+ private:
+  bool initialized_;
+  SdchOwner* initialization_observer_;
+
+  base::DictionaryValue storage_;
+};
+
 }  // namespace
 
-namespace net {
-
 static const char generic_url[] = "http://www.example.com";
 static const char generic_domain[] = "www.example.com";
 
 static std::string NewSdchDictionary(size_t dictionary_size) {
   std::string dictionary;
   dictionary.append("Domain: ");
   dictionary.append(generic_domain);
   dictionary.append("\n");
   dictionary.append("\n");
 
@@ skipping 176 matching lines @@
 //      * Either of the above, having previously added dictionaries to create
 //        a particular initial state.
 class SdchOwnerTest : public testing::Test {
  public:
   static const size_t kMaxSizeForTesting = 1000 * 50;
   static const size_t kMinFetchSpaceForTesting = 500;
 
   SdchOwnerTest()
       : last_jobs_created_(error_jobs_created),
         dictionary_creation_index_(0),
-        pref_store_(new TestingPrefStore),
         sdch_owner_(new SdchOwner(&sdch_manager_, &url_request_context_)) {
     // Any jobs created on this context will immediately error,
     // which leaves the test in control of signals to SdchOwner.
     url_request_context_.set_job_factory(&job_factory_);
 
     // Reduce sizes to reduce time for string operations.
     sdch_owner_->SetMaxTotalDictionarySize(kMaxSizeForTesting);
     sdch_owner_->SetMinSpaceForDictionaryFetch(kMinFetchSpaceForTesting);
   }
 
   SdchManager& sdch_manager() { return sdch_manager_; }
   SdchOwner& sdch_owner() { return *(sdch_owner_.get()); }
   BoundNetLog& bound_net_log() { return net_log_; }
-  TestingPrefStore& pref_store() { return *(pref_store_.get()); }
 
   int JobsRecentlyCreated() {
     int result = error_jobs_created - last_jobs_created_;
     last_jobs_created_ = error_jobs_created;
     return result;
   }
 
   bool DictionaryPresentInManager(const std::string& server_hash) {
     // Presumes all tests use generic url.
     SdchProblemCode tmp;
@@ skipping 61 matching lines @@
   int last_jobs_created_;
   BoundNetLog net_log_;
   int dictionary_creation_index_;
 
   // The dependencies of these objects (sdch_owner_ -> {sdch_manager_,
   // url_request_context_}, url_request_context_->job_factory_) require
   // this order for correct destruction semantics.
   MockURLRequestJobFactory job_factory_;
   URLRequestContext url_request_context_;
   SdchManager sdch_manager_;
-  scoped_refptr<TestingPrefStore> pref_store_;
   scoped_ptr<SdchOwner> sdch_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchOwnerTest);
 };
 
 // Does OnGetDictionary result in a fetch when there's enough space, and not
 // when there's not?
 TEST_F(SdchOwnerTest, OnGetDictionary_Fetching) {
   GURL request_url(std::string(generic_url) + "/r1");
 
@@ skipping 306 matching lines @@
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d1));
   EXPECT_FALSE(DictionaryPresentInManager(server_hash_d2));
 
   // Addition should now succeed.
   EXPECT_TRUE(
       CreateAndAddDictionary(kMaxSizeForTesting, base::Time::Now(), nullptr));
 }
 
 // Confirm that use of a pinned dictionary after its removal works properly.
 TEST_F(SdchOwnerTest, PinRemoveUse) {
-  pref_store().SetInitializationCompleted();
-  sdch_owner().EnablePersistentStorage(&pref_store());
+  // Pass ownership of the storage to the SdchOwner, but keep a pointer.
+  TestPrefStorage* pref_store = new TestPrefStorage(true);
+  sdch_owner().EnablePersistentStorage(
+      scoped_ptr<SdchOwner::PrefStorage>(pref_store));
 
   std::string server_hash_d1;
   EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 2, base::Time::Now(),
                                      &server_hash_d1));
 
   scoped_ptr<SdchManager::DictionarySet> return_set(
       sdch_manager().GetDictionarySet(
           GURL(std::string(generic_url) + "/x.html")));
   ASSERT_TRUE(return_set.get());
   EXPECT_TRUE(return_set->GetDictionaryText(server_hash_d1));
 
   const base::Value* result = nullptr;
   const base::DictionaryValue* dict_result = nullptr;
-  ASSERT_TRUE(pref_store().GetValue("SDCH", &result));
-  ASSERT_TRUE(result->GetAsDictionary(&dict_result));
+  ASSERT_TRUE(pref_store->GetValue(&dict_result));
   EXPECT_TRUE(dict_result->Get("dictionaries", &result));
   EXPECT_TRUE(dict_result->Get("dictionaries." + server_hash_d1, &result));
 
   sdch_manager().ClearData();
 
-  ASSERT_TRUE(pref_store().GetValue("SDCH", &result));
-  ASSERT_TRUE(result->GetAsDictionary(&dict_result));
+  ASSERT_TRUE(pref_store->GetValue(&dict_result));
   EXPECT_TRUE(dict_result->Get("dictionaries", &result));
   EXPECT_FALSE(dict_result->Get("dictionaries." + server_hash_d1, &result));
 
   scoped_ptr<SdchManager::DictionarySet> return_set2(
       sdch_manager().GetDictionarySet(
           GURL(std::string(generic_url) + "/x.html")));
   EXPECT_FALSE(return_set2.get());
 
   sdch_manager().OnDictionaryUsed(server_hash_d1);
 
-  ASSERT_TRUE(pref_store().GetValue("SDCH", &result));
-  ASSERT_TRUE(result->GetAsDictionary(&dict_result));
+  ASSERT_TRUE(pref_store->GetValue(&dict_result));
   EXPECT_TRUE(dict_result->Get("dictionaries", &result));
   EXPECT_FALSE(dict_result->Get("dictionaries." + server_hash_d1, &result));
 }
 
 TEST_F(SdchOwnerTest, UsageIntervalMetrics) {
   const GURL url("http://www.example.com/dict0");
 
   std::string server_hash;
   base::Time last_used_time(base::Time::Now() - base::TimeDelta::FromHours(23));
   base::Time created_time(base::Time::Now() - base::TimeDelta::FromHours(47));
 
   EXPECT_TRUE(CreateAndAddDictionary(kMaxSizeForTesting / 3, last_used_time,
                                      created_time, &server_hash));
 
   base::HistogramTester tester;
 
   sdch_owner().OnDictionaryUsed(server_hash);
   tester.ExpectTotalCount("Sdch3.FirstUseInterval", 1);
   tester.ExpectTotalCount("Sdch3.UsageInterval2", 0);
 
   sdch_owner().OnDictionaryUsed(server_hash);
   tester.ExpectTotalCount("Sdch3.FirstUseInterval", 1);  // count didn't change
   tester.ExpectTotalCount("Sdch3.UsageInterval2", 1);
 }
 
 class SdchOwnerPersistenceTest : public ::testing::Test {
  public:
-  SdchOwnerPersistenceTest() : pref_store_(new TestingPrefStore()) {
-    pref_store_->SetInitializationCompleted();
-  }
+  SdchOwnerPersistenceTest() {}
   virtual ~SdchOwnerPersistenceTest() {}
 
   void ClearOwner() {
     owner_.reset(NULL);
   }
 
-  void ResetOwner(bool delay) {
+  // If the storage points is non-null it will be saved as the persistent
+  // storage for the SdchOwner.
+  void ResetOwner(scoped_ptr<SdchOwner::PrefStorage> storage) {
     // This has to be done first, since SdchOwner may be observing SdchManager,
     // and SdchManager can't be destroyed with a live observer.
     owner_.reset(NULL);
     manager_.reset(new SdchManager());
     fetcher_ = new MockSdchDictionaryFetcher();
     owner_.reset(new SdchOwner(manager_.get(),
                                &url_request_context_));
     owner_->SetMaxTotalDictionarySize(SdchOwnerTest::kMaxSizeForTesting);
     owner_->SetMinSpaceForDictionaryFetch(
         SdchOwnerTest::kMinFetchSpaceForTesting);
     owner_->SetFetcherForTesting(make_scoped_ptr(fetcher_));
-    if (!delay)
-      owner_->EnablePersistentStorage(pref_store_.get());
+    if (storage)
+      owner_->EnablePersistentStorage(std::move(storage));
   }
 
   void InsertDictionaryForURL(const GURL& url, const std::string& nonce) {
     owner_->OnDictionaryFetched(base::Time::Now(), base::Time::Now(), 1,
                                 CreateDictionary(url, nonce), url, net_log_,
                                 false);
   }
 
   bool CompleteLoadFromURL(const GURL& url, const std::string& nonce,
                            bool was_from_cache) {
     return fetcher_->CompletePendingRequest(url, CreateDictionary(url, nonce),
                                             net_log_, was_from_cache);
   }
 
   std::string CreateDictionary(const GURL& url, const std::string& nonce) {
     std::string dict;
     dict.append("Domain: ");
     dict.append(url.host());
     dict.append("\n\n");
     dict.append(url.spec());
     dict.append(nonce);
     return dict;
   }
 
  protected:
   BoundNetLog net_log_;
-  scoped_refptr<TestingPrefStore> pref_store_;
   scoped_ptr<SdchManager> manager_;
   MockSdchDictionaryFetcher* fetcher_;
   scoped_ptr<SdchOwner> owner_;
   TestURLRequestContext url_request_context_;
 };
 
 // Test an empty persistence store.
 TEST_F(SdchOwnerPersistenceTest, Empty) {
-  ResetOwner(false);
+  ResetOwner(make_scoped_ptr(new TestPrefStorage(true)));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
 }
 
-// Test a persistence store with an empty dictionary.
-TEST_F(SdchOwnerPersistenceTest, Persistent_EmptyDict) {
-  pref_store_->SetValue("SDCH", make_scoped_ptr(new base::DictionaryValue()),
-                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  ResetOwner(false);
-  EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
-}
-
 // Test a persistence store with a bad version number.
 TEST_F(SdchOwnerPersistenceTest, Persistent_BadVersion) {
   scoped_ptr<base::DictionaryValue> sdch_dict(new base::DictionaryValue());
   sdch_dict->SetInteger("version", 2);
-  pref_store_->SetValue("SDCH", std::move(sdch_dict),
-                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
-  ResetOwner(false);
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  storage->SetValue(std::move(sdch_dict));
+
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
+
+  storage.reset(new TestPrefStorage(*old_storage));
+  ResetOwner(std::move(storage));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
 }
 
 // Test a persistence store with an empty dictionaries map.
 TEST_F(SdchOwnerPersistenceTest, Persistent_EmptyDictList) {
   scoped_ptr<base::DictionaryValue> sdch_dict(new base::DictionaryValue());
   scoped_ptr<base::DictionaryValue> dicts(new base::DictionaryValue());
   sdch_dict->SetInteger("version", 1);
   sdch_dict->Set("dictionaries", std::move(dicts));
-  pref_store_->SetValue("SDCH", std::move(sdch_dict),
-                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
-  ResetOwner(false);
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  storage->SetValue(std::move(sdch_dict));
+  ResetOwner(std::move(storage));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
 }
 
 TEST_F(SdchOwnerPersistenceTest, OneDict) {
   const GURL url("http://www.example.com/dict");
-  ResetOwner(false);
+
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
   InsertDictionaryForURL(url, "0");
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
 
-  ResetOwner(false);
+  storage.reset(new TestPrefStorage(*old_storage));
+  ResetOwner(std::move(storage));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
   EXPECT_TRUE(CompleteLoadFromURL(url, "0", true));
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
 }
 
 TEST_F(SdchOwnerPersistenceTest, TwoDicts) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
-  ResetOwner(false);
+
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   InsertDictionaryForURL(url0, "0");
   InsertDictionaryForURL(url1, "1");
 
-  ResetOwner(false);
+  storage.reset(new TestPrefStorage(*old_storage));
+  ResetOwner(std::move(storage));
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_TRUE(CompleteLoadFromURL(url1, "1", true));
   EXPECT_EQ(2, owner_->GetDictionaryCountForTesting());
   EXPECT_TRUE(owner_->HasDictionaryFromURLForTesting(url0));
   EXPECT_TRUE(owner_->HasDictionaryFromURLForTesting(url1));
 }
 
 TEST_F(SdchOwnerPersistenceTest, OneGoodDictOneBadDict) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
-  ResetOwner(false);
+
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));                // Takes ownership of storage.
   InsertDictionaryForURL(url0, "0");
   InsertDictionaryForURL(url1, "1");
 
-  // Mutate the pref store a bit now. Clear the owner first, to ensure that the
-  // SdchOwner doesn't observe these changes and object. The manual dictionary
-  // manipulation is a bit icky.
-  ClearOwner();
+  // Make a new storage based on the current contents of the old one.
+  storage.reset(new TestPrefStorage(*old_storage));
   base::DictionaryValue* dict = nullptr;
-  ASSERT_TRUE(GetDictionaryForURL(pref_store_.get(), url1, nullptr, &dict));
+  ASSERT_TRUE(GetDictionaryForURL(storage.get(), url1, nullptr, &dict));
   dict->Remove("use_count", nullptr);
 
-  ResetOwner(false);
+  ResetOwner(std::move(storage));
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_FALSE(CompleteLoadFromURL(url1, "1", true));
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
   EXPECT_TRUE(owner_->HasDictionaryFromURLForTesting(url0));
   EXPECT_FALSE(owner_->HasDictionaryFromURLForTesting(url1));
 }
 
 TEST_F(SdchOwnerPersistenceTest, UsingDictionaryUpdatesUseCount) {
   const GURL url("http://www.example.com/dict");
-  ResetOwner(false);
+
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   InsertDictionaryForURL(url, "0");
 
   std::string hash;
   int old_count;
+  storage.reset(new TestPrefStorage(*old_storage));
   {
     ClearOwner();
     base::DictionaryValue* dict = nullptr;
-    ASSERT_TRUE(GetDictionaryForURL(pref_store_.get(), url, &hash, &dict));
+    ASSERT_TRUE(GetDictionaryForURL(storage.get(), url, &hash, &dict));
     ASSERT_TRUE(dict->GetInteger("use_count", &old_count));
   }
 
-  ResetOwner(false);
+  old_storage = storage.get();     // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   ASSERT_TRUE(CompleteLoadFromURL(url, "0", true));
   owner_->OnDictionaryUsed(hash);
 
   int new_count;
   {
-    ClearOwner();
     base::DictionaryValue* dict = nullptr;
-    ASSERT_TRUE(GetDictionaryForURL(pref_store_.get(), url, nullptr, &dict));
+    ASSERT_TRUE(GetDictionaryForURL(old_storage, url, nullptr, &dict));
     ASSERT_TRUE(dict->GetInteger("use_count", &new_count));
   }
 
   EXPECT_EQ(old_count + 1, new_count);
 }
 
 TEST_F(SdchOwnerPersistenceTest, LoadingDictionaryMerges) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
 
-  ResetOwner(false);
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
   InsertDictionaryForURL(url1, "1");
 
-  ResetOwner(true);
+  storage.reset(new TestPrefStorage(*old_storage));
+  ResetOwner(scoped_ptr<SdchOwner::PrefStorage>());
   InsertDictionaryForURL(url0, "0");
   EXPECT_EQ(1, owner_->GetDictionaryCountForTesting());
-  owner_->EnablePersistentStorage(pref_store_.get());
+  owner_->EnablePersistentStorage(std::move(storage));
   ASSERT_TRUE(CompleteLoadFromURL(url1, "1", true));
   EXPECT_EQ(2, owner_->GetDictionaryCountForTesting());
 }
 
 TEST_F(SdchOwnerPersistenceTest, PersistenceMetrics) {
   const GURL url0("http://www.example.com/dict0");
   const GURL url1("http://www.example.com/dict1");
-  ResetOwner(false);
+
+  scoped_ptr<TestPrefStorage> storage(new TestPrefStorage(true));
+  TestPrefStorage* old_storage = storage.get();  // Save storage pointer.
+  ResetOwner(std::move(storage));  // Takes ownership of storage pointer.
 
   InsertDictionaryForURL(url0, "0");
   InsertDictionaryForURL(url1, "1");
 
-  ResetOwner(false);
+  storage.reset(new TestPrefStorage(*old_storage));
+  ResetOwner(std::move(storage));
 
   base::HistogramTester tester;
 
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_TRUE(CompleteLoadFromURL(url1, "1", false));
 
   tester.ExpectTotalCount("Sdch3.NetworkBytesSpent", 1);
   tester.ExpectUniqueSample("Sdch3.NetworkBytesSpent",
                             CreateDictionary(url1, "1").size(), 1);
 }
 
 }  // namespace net