Introduce incognito preference settings.

chrome/browser/extensions/extension_prefs_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "base/stringprintf.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_observer_mock.h"
 #include "chrome/common/notification_source.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 using base::TimeDelta;
 
+namespace {
+
 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";
 
+}  // namespace
+
 static void AddPattern(ExtensionExtent* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
 static void AssertEqualExtents(ExtensionExtent* extent1,
                                ExtensionExtent* extent2) {
   std::vector<URLPattern> patterns1 = extent1->patterns();
   std::vector<URLPattern> patterns2 = extent2->patterns();
   std::set<std::string> strings1;
@@ skipping 538 matching lines @@
   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;
-      }
-    }
+    EnsureExtensionInstalled(ext);
+    prefs()->SetExtensionControlledPref(ext->id(), key, false, val);
+  }
 
-    prefs()->SetExtensionControlledPref(ext->id(), key, val);
+  void InstallExtControlledPrefIncognito(Extension *ext,
+                                         const std::string& key,
+                                         Value* val) {
+    EnsureExtensionInstalled(ext);
+    prefs()->SetExtensionControlledPref(ext->id(), key, true, val);
+  }
+
+  void InstallExtension(Extension *ext) {
+    EnsureExtensionInstalled(ext);
   }
 
   void UninstallExtension(const std::string& extension_id) {
-    prefs()->OnExtensionUninstalled(extension_id, Extension::INTERNAL, false);
+    EnsureExtensionUninstalled(extension_id);
   }
 
   // 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:
+  void EnsureExtensionInstalled(Extension *ext) {
+    // 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;
+      }
+    }
+  }
+
+  void EnsureExtensionUninstalled(const std::string& extension_id) {
+    Extension* extensions[] = {ext1_, ext2_, ext3_};
+    for (int i = 0; i < 3; ++i) {
+      if (extensions[i]->id() == extension_id) {
+        installed[i] = false;
+        break;
+      }
+    }
+    prefs()->OnExtensionUninstalled(extension_id, Extension::INTERNAL, false);
+  }
+
   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 for each preference.
-class ExtensionPrefsInstallOverwrittenExtensions
+// Check that we forget incognito values after a reload.
+class ExtensionPrefsInstallIncognito
+    : public ExtensionPrefsPreferencesBase {
+ public:
+  ExtensionPrefsInstallIncognito() : iteration_(0) {}
+
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPrefIncognito(ext1_, kPref1,
+                                      Value::CreateStringValue("val2"));
+    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    std::string actual = incog_prefs->GetString(kPref1);
+    EXPECT_EQ("val2", actual);
+  }
+  virtual void Verify() {
+    // Main pref service shall see only non-incognito settings.
+    std::string actual = prefs()->pref_service()->GetString(kPref1);
+    EXPECT_EQ("val1", actual);
+    // Incognito pref service shall see incognito values only during first run.
+    // Once the pref service was reloaded, all values shall be discarded.
+    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    actual = incog_prefs->GetString(kPref1);
+    if (iteration_ == 0) {
+      EXPECT_EQ("val2", actual);
+    } else {
+      EXPECT_EQ("val1", actual);
+    }
+    ++iteration_;
+  }
+  int iteration_;
+};
+TEST_F(ExtensionPrefsInstallIncognito, ExtensionPrefsInstallOneExtension) {}
+
+class ExtensionPrefsUninstallExtension
     : 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) {}
+TEST_F(ExtensionPrefsUninstallExtension,
+    ExtensionPrefsUninstallExtension) {}
 
-// 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 triggering of notifications to registered observers
+// Tests triggering of notifications to registered observers.
 class ExtensionPrefsNotifyWhenNeeded
     : public ExtensionPrefsPreferencesBase {
   virtual void Initialize() {
     using testing::_;
     using testing::Mock;
     using testing::StrEq;
 
     scoped_ptr<NotificationObserverMock> observer(

[Mattias Nissler (ping if slow), 2011/01/07 10:12:58]

Any reason for not allocating the observers on the stack?

[battre, 2011/01/10 16:55:47]

Done.

         new NotificationObserverMock());
     PrefChangeRegistrar registrar;
     registrar.Init(prefs()->pref_service());
     registrar.Add(kPref1, observer.get());
 
+    scoped_ptr<NotificationObserverMock> incognito_observer(
+            new NotificationObserverMock());
+    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    PrefChangeRegistrar incognito_registrar;
+    incognito_registrar.Init(incog_prefs.get());
+    incognito_registrar.Add(kPref1, incognito_observer.get());
+
+    // Write value and check notification.
     EXPECT_CALL(*observer, Observe(_, _, _));
+    EXPECT_CALL(*incognito_observer, Observe(_, _, _));
     InstallExtControlledPref(ext1_, kPref1,
         Value::CreateStringValue("https://www.chromium.org"));
     Mock::VerifyAndClearExpectations(observer.get());
+    Mock::VerifyAndClearExpectations(incognito_observer.get());
 
+    // Write same value.
     EXPECT_CALL(*observer, Observe(_, _, _)).Times(0);
+    EXPECT_CALL(*incognito_observer, Observe(_, _, _)).Times(0);
     InstallExtControlledPref(ext1_, kPref1,
         Value::CreateStringValue("https://www.chromium.org"));
     Mock::VerifyAndClearExpectations(observer.get());
+    Mock::VerifyAndClearExpectations(incognito_observer.get());
 
-    EXPECT_CALL(*observer, Observe(_, _, _)).Times(2);
+    // Change value.
+    EXPECT_CALL(*observer, Observe(_, _, _));
+    EXPECT_CALL(*incognito_observer, Observe(_, _, _));
     InstallExtControlledPref(ext1_, kPref1,
         Value::CreateStringValue("chrome://newtab"));
+    Mock::VerifyAndClearExpectations(observer.get());
+    Mock::VerifyAndClearExpectations(incognito_observer.get());
 
+    // Change only incognito value.
+    EXPECT_CALL(*observer, Observe(_, _, _)).Times(0);
+    EXPECT_CALL(*incognito_observer, Observe(_, _, _));
+    InstallExtControlledPrefIncognito(ext1_, kPref1,
+        Value::CreateStringValue("chrome://newtab2"));
+    Mock::VerifyAndClearExpectations(observer.get());
+    Mock::VerifyAndClearExpectations(incognito_observer.get());
+
+    // Uninstall.
+    EXPECT_CALL(*observer, Observe(_, _, _));
+    EXPECT_CALL(*incognito_observer, Observe(_, _, _));
     UninstallExtension(ext1_->id());
+    Mock::VerifyAndClearExpectations(observer.get());
+    Mock::VerifyAndClearExpectations(incognito_observer.get());
+
     registrar.Remove(kPref1, observer.get());
+    incognito_registrar.Remove(kPref1, incognito_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
+// 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
+// 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);
@@ skipping 12 matching lines @@
   }
   MOCK_METHOD0(Die, void());
 };
 
 class ExtensionPrefsSetExtensionControlledPref
     : public ExtensionPrefsPreferencesBase {
  public:
   virtual void Initialize() {
     MockStringValue* v1 = new MockStringValue("https://www.chromium.org");
     MockStringValue* v2 = new MockStringValue("https://www.chromium.org");
+    MockStringValue* v1i = new MockStringValue("https://www.chromium.org");
+    MockStringValue* v2i = new MockStringValue("https://www.chromium.org");
     // Ownership is taken, value shall not be deleted.
     EXPECT_CALL(*v1, Die()).Times(0);
+    EXPECT_CALL(*v1i, Die()).Times(0);
     InstallExtControlledPref(ext1_, kPref1, v1);
+    InstallExtControlledPrefIncognito(ext1_, kPref1, v1i);
     testing::Mock::VerifyAndClearExpectations(v1);
+    testing::Mock::VerifyAndClearExpectations(v1i);
     // Make sure there is no memory leak and both values are deleted.
+    EXPECT_CALL(*v1, Die()).Times(1);
+    EXPECT_CALL(*v1i, Die()).Times(1);
     EXPECT_CALL(*v2, Die()).Times(1);
-    EXPECT_CALL(*v1, Die()).Times(1);
+    EXPECT_CALL(*v2i, Die()).Times(1);
     InstallExtControlledPref(ext1_, kPref1, v2);
+    InstallExtControlledPrefIncognito(ext1_, kPref1, v2i);
     prefs_.RecreateExtensionPrefs();
+    testing::Mock::VerifyAndClearExpectations(v1);
+    testing::Mock::VerifyAndClearExpectations(v1i);
+    testing::Mock::VerifyAndClearExpectations(v2);
+    testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
   virtual void Verify() {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}