Enable incognito_session_only preferences

chrome/browser/extensions/extension_prefs_unittest.cc

 // 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"
@@ skipping 691 matching lines @@
 
   void InstallExtControlledPrefIncognito(Extension *ext,
                                          const std::string& key,
                                          Value* val) {
     using namespace extension_prefs_scope;
     EnsureExtensionInstalled(ext);
     prefs()->SetExtensionControlledPref(ext->id(), key,
                                         kIncognitoPersistent, val);
   }
 
+  void InstallExtControlledPrefIncognitoSessionOnly(
+      Extension *ext,
+      const std::string& key,
+      Value* val) {
+    using namespace extension_prefs_scope;
+    EnsureExtensionInstalled(ext);
+    prefs()->SetExtensionControlledPref(ext->id(), key,
+                                        kIncognitoSessionOnly, val);
+  }
+
   void InstallExtension(Extension *ext) {
     EnsureExtensionInstalled(ext);
   }
 
   void UninstallExtension(const std::string& extension_id) {
     EnsureExtensionUninstalled(extension_id);
   }
 
   // Weak references, for convenience.
   Extension* ext1_;
@@ skipping 38 matching lines @@
     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 do not forget persistent incognito values after a reload.
-class ExtensionPrefsInstallIncognito
+class ExtensionPrefsInstallIncognitoPersistent
     : public ExtensionPrefsPreferencesBase {
  public:
   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.
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
 };
-TEST_F(ExtensionPrefsInstallIncognito, ExtensionPrefsInstallOneExtension) {}
+TEST_F(ExtensionPrefsInstallIncognitoPersistent,
+       ExtensionPrefsInstallOneExtension) {}
+
+// Check that we forget 'session only' incognito values after a reload.
+class ExtensionPrefsInstallIncognitoSessionOnly
+    : public ExtensionPrefsPreferencesBase {
+ public:
+  ExtensionPrefsInstallIncognitoSessionOnly() : iteration_(0) {}
+
+  virtual void Initialize() {
+    InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPrefIncognitoSessionOnly(
+        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 session-only 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(ExtensionPrefsInstallIncognitoSessionOnly,
+       ExtensionPrefsInstallOneExtension) {}
 
 class ExtensionPrefsUninstallExtension
     : public ExtensionPrefsPreferencesBase {
   virtual void Initialize() {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     InstallExtControlledPref(ext1_, kPref2, Value::CreateStringValue("val2"));
 
     UninstallExtension(ext1_->id());
   }
   virtual void Verify() {
@@ skipping 43 matching lines @@
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     // Change value.
     EXPECT_CALL(observer, Observe(_, _, _));
     EXPECT_CALL(incognito_observer, Observe(_, _, _));
     InstallExtControlledPref(ext1_, kPref1,
         Value::CreateStringValue("chrome://newtab"));
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
-    // Change only incognito value.
+    // Change only incognito persistent value.
     EXPECT_CALL(observer, Observe(_, _, _)).Times(0);
     EXPECT_CALL(incognito_observer, Observe(_, _, _));
     InstallExtControlledPrefIncognito(ext1_, kPref1,
         Value::CreateStringValue("chrome://newtab2"));
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
+    // Change only incognito session-only value.
+    EXPECT_CALL(observer, Observe(_, _, _)).Times(0);
+    EXPECT_CALL(incognito_observer, Observe(_, _, _));
+    InstallExtControlledPrefIncognito(ext1_, kPref1,
+        Value::CreateStringValue("chrome://newtab3"));
+    Mock::VerifyAndClearExpectations(&observer);
+    Mock::VerifyAndClearExpectations(&incognito_observer);
+
     // Uninstall.
     EXPECT_CALL(observer, Observe(_, _, _));
     EXPECT_CALL(incognito_observer, Observe(_, _, _));
     UninstallExtension(ext1_->id());
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     registrar.Remove(kPref1, &observer);
     incognito_registrar.Remove(kPref1, &incognito_observer);
   }
@@ skipping 75 matching lines @@
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
   virtual void Verify() {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}