Introduce incognito preference settings.

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 "base/stringprintf.h"
@@ skipping 573 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.
+    EnsureExtensionInstalled(ext);
+    const bool incognito = false;
+    prefs()->SetExtensionControlledPref(ext->id(), key, incognito, val);
+  }
+
+  void InstallExtControlledPrefIncognito(Extension *ext,
+                                const std::string& key,
+                                Value* val) {
+    EnsureExtensionInstalled(ext);
+    const bool incognito = true;
+    prefs()->SetExtensionControlledPref(ext->id(), key, incognito, val);
+  }
+
+  void UninstallExtension(const std::string& extension_id) {
     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;
+      if (extensions[i]->id() == extension_id) {
+        installed[i] = false;
         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:
+  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;
+      }
+    }
+  }
+
   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) {}
 
+// 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"));
+    std::string actual = prefs_.incognito_pref_service()->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
+    actual = prefs_.incognito_pref_service()->GetString(kPref1);
+    if (iteration == 0) {
+      EXPECT_EQ("val2", actual);
+    } else {
+      EXPECT_EQ("val1", actual);
+    }
+    ++iteration;
+  }
+  int iteration;
+};
+TEST_F(ExtensionPrefsInstallIncognito, ExtensionPrefsInstallOneExtension) {}
+
 // 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 for each preference.
+class ExtensionPrefsInstallOverwrittenExtensionsIncognito
+    : public ExtensionPrefsPreferencesBase {
+  virtual void Initialize() {
+    const char* strings[] = {
+        kDefaultPref1,
+        "val1",
+        "val2",
+        "val3",
+        "val4"
+    };
+    int values[][6] = {
+      // columns:
+      //   0: pref value of extension 1
+      //   1: pref value of extension 1 incognito
+      //   2: pref value of extension 2
+      //   3: pref value of extension 2 incognito
+      //   4: desired winner regular
+      //   5: desired winner incognito
+      // e.g. { 1, 0, 0, 4,  1, 4}, means:
+      // ext1 regular is set to "val1", ext2 incognito is set to "val4"
+      // --> the winning regular value is "val1", the winning incognito
+      //     value is "val4".
+      { 1, 0, 0, 0,  1, 1},
+      { 1, 2, 0, 0,  1, 2},
+      { 1, 0, 3, 0,  3, 3},
+      { 1, 0, 0, 4,  1, 4},
+      { 1, 2, 3, 0,  3, 3},  // The last 3 here is intentional!
+      { 1, 2, 0, 4,  1, 4},
+      { 1, 2, 3, 4,  3, 4}
+    };
+    InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
+    for (size_t row = 0; row < arraysize(values); ++row) {
+      LOG(INFO) << "Testing row " << row;
+      UninstallExtension(ext1_->id());
+      UninstallExtension(ext2_->id());
+      if (values[row][0]) {
+        InstallExtControlledPref(
+            ext1_, kPref1, Value::CreateStringValue(strings[values[row][0]]));
+      }
+      if (values[row][1]) {
+        InstallExtControlledPrefIncognito(
+            ext1_, kPref1, Value::CreateStringValue(strings[values[row][1]]));
+      }
+      if (values[row][2]) {
+        InstallExtControlledPref(
+            ext2_, kPref1, Value::CreateStringValue(strings[values[row][2]]));
+      }
+      if (values[row][3]) {
+        InstallExtControlledPrefIncognito(
+            ext2_, kPref1, Value::CreateStringValue(strings[values[row][3]]));
+      }
+      std::string actual;
+      actual = prefs()->pref_service()->GetString(kPref1);
+      EXPECT_EQ(strings[values[row][4]], actual);
+      actual = prefs_.incognito_pref_service()->GetString(kPref1);
+      EXPECT_EQ(strings[values[row][5]], actual);
+    }
+  }
+  virtual void Verify() {}
+};
+TEST_F(ExtensionPrefsInstallOverwrittenExtensionsIncognito,
+    ExtensionPrefsInstallOverwrittenExtensionsIncognito) {}
+
 // 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_.incognito_pref_service()->GetString(kPref1);
+    EXPECT_EQ("val7", actual);
     actual = prefs()->pref_service()->GetString(kPref2);
     EXPECT_EQ("val2", actual);
+    actual = prefs_.incognito_pref_service()->GetString(kPref2);
+    EXPECT_EQ("val2", actual);
     actual = prefs()->pref_service()->GetString(kPref3);
     EXPECT_EQ("val4", actual);
+    actual = prefs_.incognito_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"));
@@ skipping 30 matching lines @@
     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 {
+ public:
+  ExtensionPrefsUninstallExtensionFromTop() : iteration(0) {}
+
   virtual void Initialize() {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPrefIncognito(ext1_, kPref1,
+                                      Value::CreateStringValue("val1i"));
     InstallExtControlledPref(ext2_, kPref1, Value::CreateStringValue("val2"));
+    InstallExtControlledPrefIncognito(ext2_, kPref1,
+                                      Value::CreateStringValue("val2i"));
     InstallExtControlledPref(ext3_, kPref1, Value::CreateStringValue("val3"));
+    InstallExtControlledPrefIncognito(ext3_, kPref1,
+                                      Value::CreateStringValue("val3i"));
 
     InstallExtControlledPref(ext1_, kPref2, Value::CreateStringValue("val4"));
+    InstallExtControlledPrefIncognito(ext1_, kPref2,
+                                      Value::CreateStringValue("val4i"));
     InstallExtControlledPref(ext3_, kPref2, Value::CreateStringValue("val5"));
+    InstallExtControlledPrefIncognito(ext3_, kPref2,
+                                      Value::CreateStringValue("val5i"));
 
     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);
+    // After the reload (iteration == 1) all incognito settings are forgotten.
+    actual = prefs_.incognito_pref_service()->GetString(kPref1);
+    EXPECT_EQ((iteration == 0 ? "val2i" : "val2"), actual);
+    actual = prefs_.incognito_pref_service()->GetString(kPref2);
+    EXPECT_EQ((iteration == 0 ? "val4i" : "val4"), actual);
+    ++iteration;
   }
+  int iteration;
 };
 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"));
@@ skipping 104 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) {}