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

chrome/browser/extensions/extension_prefs_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 "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
+#include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/notification_details.h"
+#include "chrome/common/notification_source.h"
+#include "chrome/common/notification_type.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
 // Base class for tests.
 class ExtensionPrefsTest : public testing::Test {
  public:
   ExtensionPrefsTest() {}
 
   // This function will get called once, and is the right place to do operations
   // on ExtensionPrefs that write data.
   virtual void Initialize() = 0;
 
   // This function will be called twice - once while the original ExtensionPrefs
   // object is still alive, and once after recreation. Thus, it tests that
   // things don't break after any ExtensionPrefs startup work.
   virtual void Verify() = 0;
 
+  // This function is called to Register preference default values.
+  virtual void RegisterPreferences() {}
+
   virtual void SetUp() {
+    RegisterPreferences();
     Initialize();
   }
 
   virtual void TearDown() {
     Verify();
 
     // Reset ExtensionPrefs, and re-verify.
     prefs_.RecreateExtensionPrefs();
+    RegisterPreferences();
     Verify();
   }
 
  protected:
   ExtensionPrefs* prefs() { return prefs_.prefs(); }
 
   TestExtensionPrefs prefs_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefsTest);
 };
 
+// Mock MockObserver that allows the notifications to be tracked.
+class MockObserver : public NotificationObserver {
+ public:
+  MockObserver() {}
+  virtual ~MockObserver() {}
+  MOCK_METHOD3(Observe, void(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details));
+};
+
 // Tests the LastPingDay/SetLastPingDay functions.
 class ExtensionPrefsLastPingDay : public ExtensionPrefsTest {
  public:
   ExtensionPrefsLastPingDay()
       : extension_time_(Time::Now() - TimeDelta::FromHours(4)),
         blacklist_time_(Time::Now() - TimeDelta::FromHours(2)) {}
 
   virtual void Initialize() {
     extension_id_ = prefs_.AddExtensionAndReturnId("last_ping_day");
     EXPECT_TRUE(prefs()->LastPingDay(extension_id_).is_null());
@@ skipping 112 matching lines @@
     EXPECT_EQ(NULL, prefs()->GetInstalledExtensionInfo(not_installed_id_));
 
     ExtensionList::const_iterator iter;
     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
       EXPECT_FALSE(prefs()->IsExtensionBlacklisted((*iter)->id()));
     }
     // Blacklist one installed and one not-installed extension id.
     std::set<std::string> blacklisted_ids;
     blacklisted_ids.insert(extensions_[0]->id());
     blacklisted_ids.insert(not_installed_id_);
+
+    // TODO(battre) This prints some nasty "Error parsing installation time of
+    // extension" messages because the extension preferences have incomplete
+    // dictionaries (they contain only the blacklist-property).
     prefs()->UpdateBlacklist(blacklisted_ids);
   }
 
   virtual void Verify() {
     // Make sure the two id's we expect to be blacklisted are.
     EXPECT_TRUE(prefs()->IsExtensionBlacklisted(extensions_[0]->id()));
     EXPECT_TRUE(prefs()->IsExtensionBlacklisted(not_installed_id_));
 
     // Make sure the other id's are not blacklisted.
     ExtensionList::const_iterator iter;
@@ skipping 131 matching lines @@
     EXPECT_TRUE(prefs()->IsIncognitoEnabled(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsOnExtensionInstalled,
        ExtensionPrefsOnExtensionInstalled) {}
 
 class ExtensionPrefsAppLaunchIndex : public ExtensionPrefsTest {
-public:
+ public:
   virtual void Initialize() {
     // No extensions yet.
     EXPECT_EQ(0, prefs()->GetNextAppLaunchIndex());
 
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_EQ(Extension::ENABLED,
         prefs()->GetExtensionState(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
         Extension::ENABLED, false);
   }
 
   virtual void Verify() {
     int launch_index = prefs()->GetAppLaunchIndex(extension_->id());
     // Extension should have been assigned a launch index > 0.
     EXPECT_GT(launch_index, 0);
     EXPECT_EQ(launch_index + 1, prefs()->GetNextAppLaunchIndex());
     // Set a new launch index of one higher and verify.
     prefs()->SetAppLaunchIndex(extension_->id(),
         prefs()->GetNextAppLaunchIndex());
     int new_launch_index = prefs()->GetAppLaunchIndex(extension_->id());
     EXPECT_EQ(launch_index + 1, new_launch_index);
 
     // This extension doesn't exist, so it should return -1.
     EXPECT_EQ(-1, prefs()->GetAppLaunchIndex("foo"));
   }
 
-private:
+ private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsAppLaunchIndex, ExtensionPrefsAppLaunchIndex) {}
+
+namespace keys = extension_manifest_keys;
+
+// 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";
+
+// Default values in case an extension pref value is not overridden.
+const char kDefaultPref1[] = "default pref 1";
+const char kDefaultPref2[] = "default pref 2";
+const char kDefaultPref3[] = "default pref 3";
+const char kDefaultPref4[] = "default pref 4";
+
+class ExtensionPrefsPreferencesBase : public ExtensionPrefsTest {
+ public:
+  ExtensionPrefsPreferencesBase()
+      : ExtensionPrefsTest(),
+        ext1(NULL),
+        ext2(NULL),
+        ext3(NULL),
+        installed() {
+    DictionaryValue simple_dict;
+    std::string error;
+
+    simple_dict.SetString(keys::kVersion, "1.0.0.0");
+    simple_dict.SetString(keys::kName, "unused");
+
+    ext1_scoped_ = Extension::Create(
+        prefs_.temp_dir().AppendASCII("ext1"), Extension::INVALID,
+        simple_dict, false, &error);
+    ext2_scoped_ = Extension::Create(
+        prefs_.temp_dir().AppendASCII("ext2"), Extension::INVALID,
+        simple_dict, false, &error);
+    ext3_scoped_ = Extension::Create(
+        prefs_.temp_dir().AppendASCII("ext3"), Extension::INVALID,
+        simple_dict, false, &error);
+
+    ext1 = ext1_scoped_.get();
+    ext2 = ext2_scoped_.get();
+    ext3 = ext3_scoped_.get();
+
+    for (size_t i = 0; i < arraysize(installed); ++i)
+      installed[i] = false;
+  }
+
+  void RegisterPreferences() {
+    prefs()->pref_service()->RegisterStringPref(kPref1, kDefaultPref1);
+    prefs()->pref_service()->RegisterStringPref(kPref2, kDefaultPref2);
+    prefs()->pref_service()->RegisterStringPref(kPref3, kDefaultPref3);
+    prefs()->pref_service()->RegisterStringPref(kPref4, kDefaultPref4);
+  }
+
+  void InstallExtControlledPref(Extension *ext,
+                            const std::string& key,
+                            Value* val) {
+    // Install extension the first time a preference is set for it.
+    Extension* extensions[] = {ext1, ext2, ext3};
+    for (int i = 0; i < 3; ++i) {
+      if (ext == extensions[i] && !installed[i]) {
+        prefs()->OnExtensionInstalled(ext, Extension::ENABLED, true);
+        installed[i] = true;
+        break;
+      }
+    }
+
+    prefs()->SetExtensionControlledPref(ext->id(), key, val);
+  }
+
+  void UninstallExtension(const std::string& extension_id) {
+    prefs()->OnExtensionUninstalled(extension_id, Extension::INTERNAL, false);
+  }
+
+  // Weak references, for convenience.
+  Extension* ext1;
+  Extension* ext2;
+  Extension* ext3;
+
+  // Flags indicating whether each of the extensions has been installed, yet.
+  bool installed[3];
+
+ private:
+  scoped_refptr<Extension> ext1_scoped_;
+  scoped_refptr<Extension> ext2_scoped_;
+  scoped_refptr<Extension> ext3_scoped_;
+};
+
+class ExtensionPrefsInstallOneExtension
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+  }
+  virtual void Verify() {
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val1", actual);
+  }
+};
+TEST_F(ExtensionPrefsInstallOneExtension, ExtensionPrefsInstallOneExtension) {}
+
+// Make sure the last-installed extension wins.
+class ExtensionPrefsInstallMultipleExtensions
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext2, kPref1, Value::CreateStringValue("val2"));
+    InstallExtControlledPref(ext3, kPref1, Value::CreateStringValue("val3"));
+  }
+  virtual void Verify() {
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val3", actual);
+  }
+};
+TEST_F(ExtensionPrefsInstallMultipleExtensions,
+    ExtensionPrefsInstallMultipleExtensions) {}
+
+// Make sure the last-installed extension wins for each preference.
+class ExtensionPrefsInstallOverwrittenExtensions
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext2, kPref1, Value::CreateStringValue("val2"));
+    InstallExtControlledPref(ext3, kPref1, Value::CreateStringValue("val3"));
+
+    InstallExtControlledPref(ext1, kPref2, Value::CreateStringValue("val4"));
+    InstallExtControlledPref(ext2, kPref2, Value::CreateStringValue("val5"));
+
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val6"));
+    InstallExtControlledPref(ext1, kPref2, Value::CreateStringValue("val7"));
+    InstallExtControlledPref(ext1, kPref3, Value::CreateStringValue("val8"));
+  }
+  virtual void Verify() {
+    std::string actual;
+    actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val3", actual);
+    actual = prefs()->pref_service()->GetString(kPref2);
+    EXPECT_EQ("val5", actual);
+    actual = prefs()->pref_service()->GetString(kPref3);
+    EXPECT_EQ("val8", actual);
+  }
+};
+TEST_F(ExtensionPrefsInstallOverwrittenExtensions,
+    ExtensionPrefsInstallOverwrittenExtensions) {}
+
+// Make sure the last-installed extension wins even if other extensions set
+// the same or different preferences later.
+class ExtensionPrefsInstallInterleavedExtensions
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext2, kPref2, Value::CreateStringValue("val2"));
+    InstallExtControlledPref(ext3, kPref3, Value::CreateStringValue("val3"));
+
+    InstallExtControlledPref(ext3, kPref3, Value::CreateStringValue("val4"));
+    InstallExtControlledPref(ext2, kPref3, Value::CreateStringValue("val5"));
+    InstallExtControlledPref(ext1, kPref3, Value::CreateStringValue("val6"));
+
+    InstallExtControlledPref(ext3, kPref1, Value::CreateStringValue("val7"));
+  }
+  virtual void Verify() {
+    std::string actual;
+    actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val7", actual);
+    actual = prefs()->pref_service()->GetString(kPref2);
+    EXPECT_EQ("val2", actual);
+    actual = prefs()->pref_service()->GetString(kPref3);
+    EXPECT_EQ("val4", actual);
+  }
+};
+TEST_F(ExtensionPrefsInstallInterleavedExtensions,
+    ExtensionPrefsInstallInterleavedExtensions) {}
+
+class ExtensionPrefsUninstallOnlyExtension
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext1, kPref2, Value::CreateStringValue("val2"));
+
+    UninstallExtension(ext1->id());
+  }
+  virtual void Verify() {
+    std::string actual;
+    actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ(kDefaultPref1, actual);
+    actual = prefs()->pref_service()->GetString(kPref2);
+    EXPECT_EQ(kDefaultPref2, actual);
+  }
+};
+TEST_F(ExtensionPrefsUninstallOnlyExtension,
+    ExtensionPrefsUninstallOnlyExtension) {}
+
+// Tests uninstalling an extension that wasn't winning for any preferences.
+class ExtensionPrefsUninstallIrrelevantExtension
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext2, kPref1, Value::CreateStringValue("val2"));
+
+    InstallExtControlledPref(ext1, kPref2, Value::CreateStringValue("val3"));
+    InstallExtControlledPref(ext2, kPref2, Value::CreateStringValue("val4"));
+
+    UninstallExtension(ext1->id());
+  }
+  virtual void Verify() {
+    std::string actual;
+    actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val2", actual);
+    actual = prefs()->pref_service()->GetString(kPref2);
+    EXPECT_EQ("val4", actual);
+  }
+};
+TEST_F(ExtensionPrefsUninstallIrrelevantExtension,
+    ExtensionPrefsUninstallIrrelevantExtension) {}
+
+// Tests uninstalling an extension that was winning for all preferences.
+class ExtensionPrefsUninstallExtensionFromTop
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext2, kPref1, Value::CreateStringValue("val2"));
+    InstallExtControlledPref(ext3, kPref1, Value::CreateStringValue("val3"));
+
+    InstallExtControlledPref(ext1, kPref2, Value::CreateStringValue("val4"));
+    InstallExtControlledPref(ext3, kPref2, Value::CreateStringValue("val5"));
+
+    UninstallExtension(ext3->id());
+  }
+  virtual void Verify() {
+    std::string actual;
+    actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val2", actual);
+    actual = prefs()->pref_service()->GetString(kPref2);
+    EXPECT_EQ("val4", actual);
+  }
+};
+TEST_F(ExtensionPrefsUninstallExtensionFromTop,
+    ExtensionPrefsUninstallExtensionFromTop) {}
+
+// Tests uninstalling an extension that was winning for only some preferences.
+class ExtensionPrefsUninstallExtensionFromMiddle
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext2, kPref1, Value::CreateStringValue("val2"));
+    InstallExtControlledPref(ext3, kPref1, Value::CreateStringValue("val3"));
+
+    InstallExtControlledPref(ext1, kPref2, Value::CreateStringValue("val4"));
+    InstallExtControlledPref(ext2, kPref2, Value::CreateStringValue("val5"));
+
+    InstallExtControlledPref(ext1, kPref3, Value::CreateStringValue("val6"));
+
+    InstallExtControlledPref(ext2, kPref4, Value::CreateStringValue("val7"));
+
+    UninstallExtension(ext2->id());
+  }
+  virtual void Verify() {
+    std::string actual;
+    actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val3", actual);
+    actual = prefs()->pref_service()->GetString(kPref2);
+    EXPECT_EQ("val4", actual);
+    actual = prefs()->pref_service()->GetString(kPref3);
+    EXPECT_EQ("val6", actual);
+    actual = prefs()->pref_service()->GetString(kPref4);
+    EXPECT_EQ(kDefaultPref4, actual);
+  }
+};
+TEST_F(ExtensionPrefsUninstallExtensionFromMiddle,
+    ExtensionPrefsUninstallExtensionFromMiddle) {}
+
+// Tests uninstalling an extension that was winning for only some preferences.
+class ExtensionPrefsNotifyWhenNeeded
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    using testing::_;
+    using testing::Mock;
+    using testing::StrEq;
+
+    scoped_ptr<MockObserver> observer(new MockObserver());
+    PrefChangeRegistrar registrar;
+    registrar.Init(prefs()->pref_service());
+    registrar.Add(kPref1, observer.get());
+
+    EXPECT_CALL(*observer, Observe(_, _, _));
+    InstallExtControlledPref(ext1, kPref1,
+        Value::CreateStringValue("https://www.chromium.org"));
+    Mock::VerifyAndClearExpectations(observer.get());
+
+    EXPECT_CALL(*observer, Observe(_, _, _)).Times(0);
+    InstallExtControlledPref(ext1, kPref1,
+        Value::CreateStringValue("https://www.chromium.org"));
+    Mock::VerifyAndClearExpectations(observer.get());
+
+    EXPECT_CALL(*observer, Observe(_, _, _)).Times(2);
+    InstallExtControlledPref(ext1, kPref1,
+        Value::CreateStringValue("chrome://newtab"));
+
+    UninstallExtension(ext1->id());
+    registrar.Remove(kPref1, observer.get());
+  }
+  virtual void Verify() {
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ(kDefaultPref1, actual);
+  }
+};
+TEST_F(ExtensionPrefsNotifyWhenNeeded,
+    ExtensionPrefsNotifyWhenNeeded) {}
+
+// Tests disabling an extension
+class ExtensionPrefsDisableExt
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val1", actual);
+    prefs()->SetExtensionState(ext1, Extension::DISABLED);
+  }
+  virtual void Verify() {
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ(kDefaultPref1, actual);
+  }
+};
+TEST_F(ExtensionPrefsDisableExt,  ExtensionPrefsDisableExt) {}
+
+// Tests disabling and reenabling an extension
+class ExtensionPrefsReenableExt
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1, kPref1, Value::CreateStringValue("val1"));
+    prefs()->SetExtensionState(ext1, Extension::DISABLED);
+    prefs()->SetExtensionState(ext1, Extension::ENABLED);
+  }
+  virtual void Verify() {
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val1", actual);
+  }
+};
+TEST_F(ExtensionPrefsDisableExt,  ExtensionPrefsReenableExt) {}
+