First part to fix 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"
@@ skipping 51 matching lines @@
 
   void SetPrefService(PrefService* pref_service) {
     pref_service_ = pref_service;
   }
 
   // Overridden from ExtensionPrefStore.
   virtual PrefService* GetPrefService() {
     return pref_service_;
   }
 
+  virtual void PersistExtensionPrecedences(
+      const std::vector<std::string>& precedence) {
+    precedence_ = precedence;
+  }
+
+  virtual void GetExtensionPrecedences(
+      std::vector<std::string>* precedence) const {
+    *precedence = precedence_;
+  }
+
   // 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_;
+
+  std::vector<std::string> precedence_;
 };
 
 // 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() {}
 
@@ skipping 20 matching lines @@
 
 }  // namespace
 
 TEST(ExtensionPrefStoreTest, InstallOneExtension) {
   TestExtensionPrefStore 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;
   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]);
 
+  std::vector<std::string> precedences;
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(3u, precedences.size());
+  EXPECT_EQ(eps.ext1->id(), precedences[0]);
+  EXPECT_EQ(eps.ext2->id(), precedences[1]);
+  EXPECT_EQ(eps.ext3->id(), precedences[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;
   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]);
 
+  std::vector<std::string> precedences;
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(3u, precedences.size());
+  EXPECT_EQ(eps.ext1->id(), precedences[0]);
+  EXPECT_EQ(eps.ext2->id(), precedences[1]);
+  EXPECT_EQ(eps.ext3->id(), precedences[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;
   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]);
 
+  std::vector<std::string> precedences;
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(3u, precedences.size());
+  EXPECT_EQ(eps.ext1->id(), precedences[0]);
+  EXPECT_EQ(eps.ext2->id(), precedences[1]);
+  EXPECT_EQ(eps.ext3->id(), precedences[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;
   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());
 
+  std::vector<std::string> precedences;
+  eps.GetExtensionPrecedences(&precedences);
+  EXPECT_EQ(0u, precedences.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;
   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]);
 
+  std::vector<std::string> precedences;
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(1u, precedences.size());
+  EXPECT_EQ(eps.ext2->id(), precedences[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;
   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]);
 
+  std::vector<std::string> precedences;
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(2u, precedences.size());
+  EXPECT_EQ(eps.ext1->id(), precedences[0]);
+  EXPECT_EQ(eps.ext2->id(), precedences[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;
   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);
@@ skipping 30 matching lines @@
   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);
   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(ExtensionPrefStoreTest, InstallRegisteredExtensions) {
+  TestExtensionPrefStore eps;
+  ASSERT_TRUE(eps.ext1 != NULL);
+
+  std::vector<std::string> precedences;
+  precedences.push_back(eps.ext3->id());
+  precedences.push_back(eps.ext1->id());
+  precedences.push_back(eps.ext2->id());
+  eps.PersistExtensionPrecedences(precedences);
+
+  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);
+  }
+
+  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]);
+
+  precedences.clear();
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(3u, precedences.size());
+  EXPECT_EQ(eps.ext3->id(), precedences[0]);
+  EXPECT_EQ(eps.ext1->id(), precedences[1]);
+  EXPECT_EQ(eps.ext2->id(), precedences[2]);
+}
+
+// Make sure the precedence is respected when extensions are loaded and
+// uninstalled later.
+TEST(ExtensionPrefStoreTest, UninstallRegisteredExtensions) {
+  TestExtensionPrefStore eps;
+  ASSERT_TRUE(eps.ext1 != NULL);
+
+  std::vector<std::string> precedences;
+  precedences.push_back(eps.ext3->id());
+  precedences.push_back(eps.ext1->id());
+  precedences.push_back(eps.ext2->id());
+  eps.PersistExtensionPrecedences(precedences);
+
+  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]);
+
+  precedences.clear();
+  eps.GetExtensionPrecedences(&precedences);
+  ASSERT_EQ(2u, precedences.size());
+  EXPECT_EQ(eps.ext3->id(), precedences[0]);
+  EXPECT_EQ(eps.ext1->id(), precedences[1]);
+}
+