Fix for Bug 50726 "Save extension list and "winning" prefs from extensions"

chrome/browser/extensions/extension_pref_store_unittest.cc

Index: chrome/browser/extensions/extension_pref_store_unittest.cc
diff --git a/chrome/browser/extensions/extension_pref_store_unittest.cc b/chrome/browser/extensions/extension_pref_store_unittest.cc
index 90bed623ba78d4942840500f5c7aa4c271ec0674..2ffabaa353221841464e7b1cac0895974012aa46 100644
--- a/chrome/browser/extensions/extension_pref_store_unittest.cc
+++ b/chrome/browser/extensions/extension_pref_store_unittest.cc
@@ -21,6 +21,61 @@ namespace keys = extension_manifest_keys;
 
 namespace {
 
+class TestExtensionPrefStore;
+class MockPrefService;
+
+// Use constants to avoid confusing std::map with hard-coded strings.
+const char kPref1[] = "path1.subpath";
+const char kPref2[] = "path2";
+const char kPref3[] = "path3";
+const char kPref4[] = "path4";
+
+class ExtensionPrefStoreTest : public testing::Test {
+ public:
+  ExtensionPrefStoreTest()
+      : ui_thread_(BrowserThread::UI, &message_loop_),
+        eps_(NULL),
+        dps_(NULL),
+        value_store_(NULL),
+        pref_service_(NULL)
+        {}
+
+ protected:
+  virtual void SetUp();
+  virtual void TearDown();
+
+  MessageLoop message_loop_;
+  BrowserThread ui_thread_;
+  TestExtensionPrefStore* eps_;  // Owned by value_store_.
+  DefaultPrefStore* dps_;        // Owned by value_store_.
+  DefaultPrefStore* ups_;        // Owned by value_store_.
+  PrefValueStore* value_store_;  // Owned by pref_service_.
+  scoped_ptr<MockPrefService> pref_service_;
+};
+
+// Mock PrefNotifier that allows the notifications to be tracked.
+class MockPrefNotifier : public PrefNotifier {
+ public:
+  MockPrefNotifier(PrefService* service, PrefValueStore* value_store)
+    : PrefNotifier(service, value_store) {}
+
+  virtual ~MockPrefNotifier() {}
+
+  MOCK_METHOD1(FireObservers, void(const char* path));
+};
+
+// Mock PrefService that allows the PrefNotifier to be injected.
+class MockPrefService : public PrefService {
+ public:
+  explicit MockPrefService(PrefValueStore* pref_value_store)
+      : PrefService(pref_value_store) {
+  }
+
+  void SetPrefNotifier(MockPrefNotifier* notifier) {
+    pref_notifier_.reset(notifier);
+  }
+};
+
 class TestExtensionPrefStore : public ExtensionPrefStore {
  public:
   TestExtensionPrefStore()
@@ -65,10 +120,12 @@ class TestExtensionPrefStore : public ExtensionPrefStore {
   }
 
   // Overridden from ExtensionPrefStore.
-  virtual PrefService* GetPrefService() {
+  virtual PrefService* GetPrefService() const {
     return pref_service_;
   }
 
+  MOCK_METHOD0(SchedulePersist, void());
+
   // Weak references, for convenience.
   Extension* ext1;
   Extension* ext2;
@@ -85,45 +142,95 @@ class TestExtensionPrefStore : public ExtensionPrefStore {
   PrefService* pref_service_;
 };
 
-// Mock PrefNotifier that allows the notifications to be tracked.
-class MockPrefNotifier : public PrefNotifier {
- public:
-  MockPrefNotifier(PrefService* service, PrefValueStore* value_store)
-    : PrefNotifier(service, value_store) {}
 
-  virtual ~MockPrefNotifier() {}
+void ExtensionPrefStoreTest::SetUp() {
+  testing::Test::SetUp();
+  // NiceMock because only TestPersistence counts calls of mock methods.
+  eps_ = new testing::NiceMock<TestExtensionPrefStore>;
+  dps_ = new DefaultPrefStore;
+  ups_ = new DefaultPrefStore;
+  value_store_ = new TestingPrefService::TestingPrefValueStore(
+      NULL, eps_, NULL, ups_, NULL, dps_);
+  pref_service_.reset(new MockPrefService(value_store_));
+  eps_->SetPrefService(pref_service_.get());
+
+  pref_service_->RegisterStringPref(kPref1, "default pref 1");
+  pref_service_->RegisterStringPref(kPref2, "default pref 2");
+  pref_service_->RegisterStringPref(kPref3, "default pref 3");
+  pref_service_->RegisterStringPref(kPref4, "default pref 4");
+}
 
-  MOCK_METHOD1(FireObservers, void(const char* path));
-};
+void ExtensionPrefStoreTest::TearDown() {
+  testing::Test::TearDown();
+  pref_service_.reset(NULL);  // Frees eps_, dps_, value_store_.
+}
 
-// Mock PrefService that allows the PrefNotifier to be injected.
-class MockPrefService : public PrefService {
- public:
-  explicit MockPrefService(PrefValueStore* pref_value_store)
-      : PrefService(pref_value_store) {
-  }
+}  // namespace
 
-  void SetPrefNotifier(MockPrefNotifier* notifier) {
-    pref_notifier_.reset(notifier);
-  }
-};
+TEST_F(ExtensionPrefStoreTest, ExtensionPrefs) {
+  scoped_ptr<DictionaryValue> dict(
+      ExtensionPrefStore::ExtensionPrefs::Create("ext1"));
+  scoped_ptr<ExtensionPrefStore::ExtensionPrefs> ep(
+      new ExtensionPrefStore::ExtensionPrefs(dict.release()));
+  EXPECT_EQ("ext1", ep->extension_id());
+  EXPECT_EQ(0u, ep->pref_values()->size());
+
+  // test set/get
+  ep->Set("key", Value::CreateStringValue("value"));
+  std::string value;
+  ASSERT_TRUE(ep->Get("key") != NULL);
+  ASSERT_TRUE(ep->Get("key")->GetAsString(&value));
+  EXPECT_EQ("value", value);
+  ASSERT_EQ(1u, ep->pref_values()->size());
+  EXPECT_EQ(NULL, ep->Get("non_existing_key"));
+
+  // test delete
+  ep->Set("key", NULL);
+  ASSERT_EQ(NULL, ep->Get("key"));
+  ASSERT_EQ(0u, ep->pref_values()->size());
+}
 
-// Use constants to avoid confusing std::map with hard-coded strings.
-const char kPref1[] = "path1.subpath";
-const char kPref2[] = "path2";
-const char kPref3[] = "path3";
-const char kPref4[] = "path4";
+TEST_F(ExtensionPrefStoreTest, ExtensionStack) {
+  scoped_ptr<ListValue> extension_stack_list(new ListValue());
 
-}  // namespace
+  ExtensionPrefStore::ExtensionStack es;
+  EXPECT_FALSE(es.IsInitialized());
+  es.Init(extension_stack_list.get());
+  ASSERT_TRUE(es.IsInitialized());
+  EXPECT_EQ(0u, es.Size());
+
+  ExtensionPrefStore::ExtensionPrefs tmp = es.CreateEntry("ext1");
+  ASSERT_EQ(1u, es.Size());
+  EXPECT_EQ("ext1", tmp.extension_id());
 
-TEST(ExtensionPrefStoreTest, InstallOneExtension) {
-  TestExtensionPrefStore eps;
+  // See whether we can retrieve it as well without triggering a CHECK
+  // exception.
+  ExtensionPrefStore::ExtensionPrefs ep1 = es.Get(0);
+
+  // Check whether it has been set up properly.
+  EXPECT_EQ("ext1", ep1.extension_id());
+
+  ExtensionPrefStore::ExtensionPrefs ep2 = es.CreateEntry("ext2");
+  EXPECT_EQ("ext2", ep2.extension_id());
+
+  // Check that order is correct.
+  EXPECT_EQ("ext2", es.Get(0).extension_id());
+  EXPECT_EQ("ext1", es.Get(1).extension_id());
+
+  // Check delete.
+  es.Remove(0);
+  EXPECT_EQ(1u, es.Size());
+  EXPECT_EQ("ext1", es.Get(0).extension_id());
+}
+
+TEST_F(ExtensionPrefStoreTest, InstallOneExtension) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(1u, ids.size());
+  ASSERT_EQ(1u, ids.size());
   EXPECT_EQ(eps.ext1->id(), ids[0]);
 
   DictionaryValue* prefs = eps.prefs();
@@ -134,8 +241,8 @@ TEST(ExtensionPrefStoreTest, InstallOneExtension) {
 }
 
 // Make sure the last-installed extension wins.
-TEST(ExtensionPrefStoreTest, InstallMultipleExtensions) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, InstallMultipleExtensions) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
@@ -143,7 +250,7 @@ TEST(ExtensionPrefStoreTest, InstallMultipleExtensions) {
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(3u, ids.size());
+  ASSERT_EQ(3u, ids.size());
   EXPECT_EQ(eps.ext3->id(), ids[0]);
   EXPECT_EQ(eps.ext2->id(), ids[1]);
   EXPECT_EQ(eps.ext1->id(), ids[2]);
@@ -156,8 +263,8 @@ TEST(ExtensionPrefStoreTest, InstallMultipleExtensions) {
 }
 
 // Make sure the last-installed extension wins for each preference.
-TEST(ExtensionPrefStoreTest, InstallOverwrittenExtensions) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, InstallOverwrittenExtensions) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
@@ -172,7 +279,7 @@ TEST(ExtensionPrefStoreTest, InstallOverwrittenExtensions) {
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(3u, ids.size());
+  ASSERT_EQ(3u, ids.size());
   EXPECT_EQ(eps.ext3->id(), ids[0]);
   EXPECT_EQ(eps.ext2->id(), ids[1]);
   EXPECT_EQ(eps.ext1->id(), ids[2]);
@@ -190,8 +297,8 @@ TEST(ExtensionPrefStoreTest, InstallOverwrittenExtensions) {
 
 // Make sure the last-installed extension wins even if other extensions set
 // the same or different preferences later.
-TEST(ExtensionPrefStoreTest, InstallInterleavedExtensions) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, InstallInterleavedExtensions) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext2, kPref2, Value::CreateStringValue("val2"));
@@ -205,7 +312,7 @@ TEST(ExtensionPrefStoreTest, InstallInterleavedExtensions) {
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(3u, ids.size());
+  ASSERT_EQ(3u, ids.size());
   EXPECT_EQ(eps.ext3->id(), ids[0]);
   EXPECT_EQ(eps.ext2->id(), ids[1]);
   EXPECT_EQ(eps.ext1->id(), ids[2]);
@@ -221,8 +328,8 @@ TEST(ExtensionPrefStoreTest, InstallInterleavedExtensions) {
   EXPECT_EQ("val4", actual);
 }
 
-TEST(ExtensionPrefStoreTest, UninstallOnlyExtension) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, UninstallOnlyExtension) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val2"));
@@ -244,8 +351,8 @@ TEST(ExtensionPrefStoreTest, UninstallOnlyExtension) {
 }
 
 // Tests uninstalling an extension that wasn't winning for any preferences.
-TEST(ExtensionPrefStoreTest, UninstallIrrelevantExtension) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, UninstallIrrelevantExtension) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
@@ -257,7 +364,7 @@ TEST(ExtensionPrefStoreTest, UninstallIrrelevantExtension) {
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(1u, ids.size());
+  ASSERT_EQ(1u, ids.size());
   EXPECT_EQ(eps.ext2->id(), ids[0]);
 
   DictionaryValue* prefs = eps.prefs();
@@ -270,8 +377,8 @@ TEST(ExtensionPrefStoreTest, UninstallIrrelevantExtension) {
 }
 
 // Tests uninstalling an extension that was winning for all preferences.
-TEST(ExtensionPrefStoreTest, UninstallExtensionFromTop) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, UninstallExtensionFromTop) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
@@ -284,7 +391,7 @@ TEST(ExtensionPrefStoreTest, UninstallExtensionFromTop) {
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(2u, ids.size());
+  ASSERT_EQ(2u, ids.size());
   EXPECT_EQ(eps.ext2->id(), ids[0]);
   EXPECT_EQ(eps.ext1->id(), ids[1]);
 
@@ -298,8 +405,8 @@ TEST(ExtensionPrefStoreTest, UninstallExtensionFromTop) {
 }
 
 // Tests uninstalling an extension that was winning for only some preferences.
-TEST(ExtensionPrefStoreTest, UninstallExtensionFromMiddle) {
-  TestExtensionPrefStore eps;
+TEST_F(ExtensionPrefStoreTest, UninstallExtensionFromMiddle) {
+  TestExtensionPrefStore& eps = *eps_;
   ASSERT_TRUE(eps.ext1 != NULL);
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
   eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
@@ -316,7 +423,7 @@ TEST(ExtensionPrefStoreTest, UninstallExtensionFromMiddle) {
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
-  EXPECT_EQ(2u, ids.size());
+  ASSERT_EQ(2u, ids.size());
   EXPECT_EQ(eps.ext3->id(), ids[0]);
   EXPECT_EQ(eps.ext1->id(), ids[1]);
 
@@ -332,25 +439,17 @@ TEST(ExtensionPrefStoreTest, UninstallExtensionFromMiddle) {
   EXPECT_FALSE(prefs->GetString(kPref4, &actual));
 }
 
-TEST(ExtensionPrefStoreTest, NotifyWhenNeeded) {
+TEST_F(ExtensionPrefStoreTest, NotifyWhenNeeded) {
   using testing::Mock;
+  using testing::StrEq;
 
-  TestExtensionPrefStore* eps = new TestExtensionPrefStore;
-  DefaultPrefStore* dps = new DefaultPrefStore;
+  TestExtensionPrefStore* eps = eps_;
   ASSERT_TRUE(eps->ext1 != NULL);
 
-  // The PrefValueStore takes ownership of the PrefStores; in this case, that's
-  // only an ExtensionPrefStore. Likewise, the PrefService takes ownership of
-  // the PrefValueStore and PrefNotifier.
-  PrefValueStore* value_store = new TestingPrefService::TestingPrefValueStore(
-      NULL, eps, NULL, NULL, NULL, dps);
-  scoped_ptr<MockPrefService> pref_service(new MockPrefService(value_store));
-  MockPrefNotifier* pref_notifier = new MockPrefNotifier(pref_service.get(),
-      value_store);
-  pref_service->SetPrefNotifier(pref_notifier);
-
-  eps->SetPrefService(pref_service.get());
-  pref_service->RegisterStringPref(kPref1, std::string());
+  // The PrefService takes ownership of the PrefNotifier.
+  MockPrefNotifier* pref_notifier = new MockPrefNotifier(pref_service_.get(),
+      value_store_);
+  pref_service_->SetPrefNotifier(pref_notifier);
 
   EXPECT_CALL(*pref_notifier, FireObservers(kPref1));
   eps->InstallExtensionPref(eps->ext1, kPref1,
@@ -362,8 +461,189 @@ TEST(ExtensionPrefStoreTest, NotifyWhenNeeded) {
       Value::CreateStringValue("https://www.chromium.org"));
   Mock::VerifyAndClearExpectations(pref_notifier);
 
-  EXPECT_CALL(*pref_notifier, FireObservers(kPref1)).Times(2);
+  EXPECT_CALL(*pref_notifier, FireObservers(StrEq(kPref1))).Times(2);
   eps->InstallExtensionPref(eps->ext1, kPref1,
       Value::CreateStringValue("chrome://newtab"));
   eps->UninstallExtension(eps->ext1);
 }
+
+// Make sure the precedence is respected when extensions are loaded
+// and the precedence of extensions has been defined in the pref stores already.
+TEST_F(ExtensionPrefStoreTest, InstallRegisteredExtensions) {
+  TestExtensionPrefStore& eps = *eps_;
+  ASSERT_TRUE(eps.ext1 != NULL);
+
+  ListValue* extensionPrefs = new ListValue();
+  ups_->prefs()->Set(ExtensionPrefStore::kExtensionPreferencesKey,
+                     extensionPrefs);
+
+  ExtensionPrefStore::ExtensionStack es;
+  es.Init(extensionPrefs);
+
+  ExtensionPrefStore::ExtensionPrefs ext3 = es.CreateEntry(eps.ext3->id());
+  ExtensionPrefStore::ExtensionPrefs ext1 = es.CreateEntry(eps.ext1->id());
+  ExtensionPrefStore::ExtensionPrefs ext2 = es.CreateEntry(eps.ext2->id());
+  // Precedence: 3 < 1 < 2 --> 3 wins.
+
+  TestExtensionPrefStore::ExtensionIDs ids;
+  eps.GetExtensionIDList(&ids);
+  ASSERT_EQ(3u, ids.size());
+  EXPECT_EQ(eps.ext2->id(), ids[0]);
+  EXPECT_EQ(eps.ext1->id(), ids[1]);
+  EXPECT_EQ(eps.ext3->id(), ids[2]);
+
+  eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
+  {
+    DictionaryValue* prefs = eps.prefs();
+    ASSERT_EQ(1u, prefs->size());
+    std::string actual;
+    EXPECT_TRUE(prefs->GetString(kPref1, &actual));
+    EXPECT_EQ("val1", actual);
+  }
+
+  // ext2 has higher higher precedence --> override.
+  eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
+  {
+    DictionaryValue* prefs = eps.prefs();
+    ASSERT_EQ(1u, prefs->size());
+    std::string actual;
+    EXPECT_TRUE(prefs->GetString(kPref1, &actual));
+    EXPECT_EQ("val2", actual);
+  }
+
+  // ext3 has lower precedence --> does not override.
+  eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val3"));
+  {
+    DictionaryValue* prefs = eps.prefs();
+    ASSERT_EQ(1u, prefs->size());
+    std::string actual;
+    EXPECT_TRUE(prefs->GetString(kPref1, &actual));
+    EXPECT_EQ("val2", actual);
+  }
+
+  ids.clear();
+  eps.GetExtensionIDList(&ids);
+  ASSERT_EQ(3u, ids.size());
+  EXPECT_EQ(eps.ext2->id(), ids[0]);
+  EXPECT_EQ(eps.ext1->id(), ids[1]);
+  EXPECT_EQ(eps.ext3->id(), ids[2]);
+}
+
+// Make sure the precedence is respected when extensions are loaded and
+// uninstalled later.
+TEST_F(ExtensionPrefStoreTest, UninstallRegisteredExtensions) {
+  TestExtensionPrefStore& eps = *eps_;
+  ASSERT_TRUE(eps.ext1 != NULL);
+
+  ListValue *extensionPrefs = new ListValue();
+  ups_->prefs()->Set(ExtensionPrefStore::kExtensionPreferencesKey,
+                     extensionPrefs);
+
+  ExtensionPrefStore::ExtensionStack es;
+  es.Init(extensionPrefs);
+
+  ExtensionPrefStore::ExtensionPrefs ext3 = es.CreateEntry(eps.ext3->id());
+  ExtensionPrefStore::ExtensionPrefs ext1 = es.CreateEntry(eps.ext1->id());
+  ExtensionPrefStore::ExtensionPrefs ext2 = es.CreateEntry(eps.ext2->id());
+  // precedence: 3 < 1 < 2 --> 3 wins
+
+  eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
+  eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
+  eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val3"));
+
+  // Correct state of this setup is ensured by InstallRegisteredExtensions test
+
+  eps.UninstallExtension(eps.ext2);
+  {
+    DictionaryValue* prefs = eps.prefs();
+    ASSERT_EQ(1u, prefs->size());
+    std::string actual;
+    EXPECT_TRUE(prefs->GetString(kPref1, &actual));
+    EXPECT_EQ("val1", actual);
+  }
+
+  TestExtensionPrefStore::ExtensionIDs ids;
+  eps.GetExtensionIDList(&ids);
+  ASSERT_EQ(2u, ids.size());
+  EXPECT_EQ(eps.ext1->id(), ids[0]);
+  EXPECT_EQ(eps.ext3->id(), ids[1]);
+}
+
+// Make sure that preregistered preference values are available before extension
+// is registered.
+TEST_F(ExtensionPrefStoreTest, ReadFromRegisteredExtensions) {
+  TestExtensionPrefStore& eps = *eps_;
+  ASSERT_TRUE(eps.ext1 != NULL);
+
+  ListValue *extensionPrefs = new ListValue();
+  ups_->prefs()->Set(ExtensionPrefStore::kExtensionPreferencesKey,
+                     extensionPrefs);
+
+  ExtensionPrefStore::ExtensionStack es;
+  es.Init(extensionPrefs);
+
+  ExtensionPrefStore::ExtensionPrefs ext1 = es.CreateEntry(eps.ext1->id());
+  ext1.Set(kPref1, Value::CreateStringValue("val1"));
+
+  TestExtensionPrefStore::ExtensionIDs ids;
+  eps.GetExtensionIDList(&ids);
+  ASSERT_EQ(1u, ids.size());
+  EXPECT_EQ(eps.ext1->id(), ids[0]);
+
+  // Check value is available before extension is started.
+  {
+    DictionaryValue* prefs = eps.prefs();
+    ASSERT_EQ(1u, prefs->size());
+    std::string actual;
+    EXPECT_TRUE(prefs->GetString(kPref1, &actual));
+    EXPECT_EQ("val1", actual);
+  }
+
+  // Check value can be overriden when extension is started.
+  eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val2"));
+  {
+    DictionaryValue* prefs = eps.prefs();
+    ASSERT_EQ(1u, prefs->size());
+    std::string actual;
+    EXPECT_TRUE(prefs->GetString(kPref1, &actual));
+    EXPECT_EQ("val2", actual);
+  }
+
+  ids.clear();
+  eps.GetExtensionIDList(&ids);
+  ASSERT_EQ(1u, ids.size());
+  EXPECT_EQ(eps.ext1->id(), ids[0]);
+}
+
+TEST_F(ExtensionPrefStoreTest, TestPersistence) {
+  // Check whether changes are persisted.
+  using testing::Mock;
+
+  TestExtensionPrefStore& eps = *eps_;
+
+  // install pref
+  EXPECT_CALL(eps, SchedulePersist());
+  eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val1"));
+  Mock::VerifyAndClearExpectations(&eps);
+
+  // overwrite by different extension
+  EXPECT_CALL(eps, SchedulePersist());
+  eps.InstallExtensionPref(eps.ext2, kPref1, Value::CreateStringValue("val2"));
+  Mock::VerifyAndClearExpectations(&eps);
+
+  // overwrite
+  EXPECT_CALL(eps, SchedulePersist());
+  eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val3"));
+  Mock::VerifyAndClearExpectations(&eps);
+
+  // add second pref
+  EXPECT_CALL(eps, SchedulePersist());
+  eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val4"));
+  Mock::VerifyAndClearExpectations(&eps);
+
+  // uninstall
+  EXPECT_CALL(eps, SchedulePersist());
+  eps.UninstallExtension(eps.ext1);
+  Mock::VerifyAndClearExpectations(&eps);
+}
+