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

chrome/browser/extensions/extension_pref_store_unittest.cc

 // Copyright (c) 2010 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 <string>
 #include <vector>
 
 #include "base/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/prefs/default_pref_store.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/testing_pref_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 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()
       : ExtensionPrefStore(NULL, PrefNotifier::EXTENSION_STORE),
         ext1(NULL),
         ext2(NULL),
         ext3(NULL),
         pref_service_(NULL) {
     // Can't use ASSERT_TRUE here because a constructor can't return a value.
     if (!temp_dir_.CreateUniqueTempDir()) {
@@ skipping 24 matching lines @@
   typedef std::vector<std::string> ExtensionIDs;
   void GetExtensionIDList(ExtensionIDs* result) {
     GetExtensionIDs(result);
   }
 
   void SetPrefService(PrefService* pref_service) {
     pref_service_ = pref_service;
   }
 
   // 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;
   Extension* ext3;
 
  private:
   ScopedTempDir temp_dir_;
 
   scoped_refptr<Extension> ext1_scoped_;
   scoped_refptr<Extension> ext2_scoped_;
   scoped_refptr<Extension> ext3_scoped_;
 
   // Weak reference.
   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());
 
-  MOCK_METHOD1(FireObservers, void(const char* path));
-};
+  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 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);
-  }
-};
-
-// 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";
+void ExtensionPrefStoreTest::TearDown() {
+  testing::Test::SetUp();

[Paweł Hajdan Jr., 2010/11/13 11:51:10]

huh? Did you mean TearDown?

[battre (please use the other), 2010/11/15 09:27:07]

Done.

+  pref_service_.reset(NULL);  // Frees eps_, dps_, value_store_.
+}
 
 }  // namespace
 
-TEST(ExtensionPrefStoreTest, InstallOneExtension) {
-  TestExtensionPrefStore eps;
+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());
+}
+
+TEST_F(ExtensionPrefStoreTest, ExtensionStack) {
+  scoped_ptr<ListValue> extension_stack_list(new ListValue());
+
+  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());
+
+  // 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();
   ASSERT_EQ(1u, prefs->size());
   std::string actual;
   ASSERT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val1", actual);
 }
 
 // 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"));
   eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val3"));
 
   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]);
 
   DictionaryValue* prefs = eps.prefs();
   ASSERT_EQ(1u, prefs->size());
   std::string actual;
   ASSERT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val3", actual);
 }
 
 // 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"));
   eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val3"));
 
   eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val4"));
   eps.InstallExtensionPref(eps.ext2, kPref2, Value::CreateStringValue("val5"));
 
   eps.InstallExtensionPref(eps.ext1, kPref1, Value::CreateStringValue("val6"));
   eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val7"));
   eps.InstallExtensionPref(eps.ext1, kPref3, Value::CreateStringValue("val8"));
 
   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]);
 
   DictionaryValue* prefs = eps.prefs();
   ASSERT_EQ(3u, prefs->size());
   std::string actual;
   EXPECT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val3", actual);
   EXPECT_TRUE(prefs->GetString(kPref2, &actual));
   EXPECT_EQ("val5", actual);
   EXPECT_TRUE(prefs->GetString(kPref3, &actual));
   EXPECT_EQ("val8", actual);
 }
 
 // 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"));
   eps.InstallExtensionPref(eps.ext3, kPref3, Value::CreateStringValue("val3"));
 
   eps.InstallExtensionPref(eps.ext3, kPref3, Value::CreateStringValue("val4"));
   eps.InstallExtensionPref(eps.ext2, kPref3, Value::CreateStringValue("val5"));
   eps.InstallExtensionPref(eps.ext1, kPref3, Value::CreateStringValue("val6"));
 
   eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val7"));
 
   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]);
 
   DictionaryValue* prefs = eps.prefs();
   ASSERT_EQ(3u, prefs->size());
   std::string actual;
   EXPECT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val7", actual);
   EXPECT_TRUE(prefs->GetString(kPref2, &actual));
   EXPECT_EQ("val2", actual);
   EXPECT_TRUE(prefs->GetString(kPref3, &actual));
   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"));
 
   // No need to check the state here; the Install* tests cover that.
   eps.UninstallExtension(eps.ext1);
 
   TestExtensionPrefStore::ExtensionIDs ids;
   eps.GetExtensionIDList(&ids);
   EXPECT_EQ(0u, ids.size());
 
   DictionaryValue* prefs = eps.prefs();
   std::string actual;
   // "path1.name" has been removed, but an empty "path1" dictionary is still
   // present.
   ASSERT_EQ(1u, prefs->size());
   EXPECT_FALSE(prefs->GetString(kPref1, &actual));
   EXPECT_FALSE(prefs->GetString(kPref2, &actual));
 }
 
 // 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"));
 
   eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val3"));
   eps.InstallExtensionPref(eps.ext2, kPref2, Value::CreateStringValue("val4"));
 
   eps.UninstallExtension(eps.ext1);
 
   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();
   ASSERT_EQ(2u, prefs->size());
   std::string actual;
   EXPECT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val2", actual);
   EXPECT_TRUE(prefs->GetString(kPref2, &actual));
   EXPECT_EQ("val4", actual);
 }
 
 // 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"));
   eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val3"));
 
   eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val4"));
   eps.InstallExtensionPref(eps.ext3, kPref2, Value::CreateStringValue("val5"));
 
   eps.UninstallExtension(eps.ext3);
 
   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]);
 
   DictionaryValue* prefs = eps.prefs();
   ASSERT_EQ(2u, prefs->size());
   std::string actual;
   EXPECT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val2", actual);
   EXPECT_TRUE(prefs->GetString(kPref2, &actual));
   EXPECT_EQ("val4", actual);
 }
 
 // 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"));
   eps.InstallExtensionPref(eps.ext3, kPref1, Value::CreateStringValue("val3"));
 
   eps.InstallExtensionPref(eps.ext1, kPref2, Value::CreateStringValue("val4"));
   eps.InstallExtensionPref(eps.ext2, kPref2, Value::CreateStringValue("val5"));
 
   eps.InstallExtensionPref(eps.ext1, kPref3, Value::CreateStringValue("val6"));
 
   eps.InstallExtensionPref(eps.ext2, kPref4, Value::CreateStringValue("val7"));
 
   eps.UninstallExtension(eps.ext2);
 
   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]);
 
   DictionaryValue* prefs = eps.prefs();
   ASSERT_EQ(3u, prefs->size());
   std::string actual;
   EXPECT_TRUE(prefs->GetString(kPref1, &actual));
   EXPECT_EQ("val3", actual);
   EXPECT_TRUE(prefs->GetString(kPref2, &actual));
   EXPECT_EQ("val4", actual);
   EXPECT_TRUE(prefs->GetString(kPref3, &actual));
   EXPECT_EQ("val6", actual);
   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,
       Value::CreateStringValue("https://www.chromium.org"));
   Mock::VerifyAndClearExpectations(pref_notifier);
 
   EXPECT_CALL(*pref_notifier, FireObservers(kPref1)).Times(0);
   eps->InstallExtensionPref(eps->ext1, kPref1,
       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);
+}
+