more changes

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.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 812 matching lines @@
   }
 
   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"));
+    InstallExtControlledPref(ext1_, kPref1, base::StringValue::New("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 ExtensionPrefsInstallIncognitoPersistent
     : public ExtensionPrefsPreferencesBase {
  public:
   virtual void Initialize() {
-    InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
+    InstallExtControlledPref(ext1_, kPref1, base::StringValue::New("val1"));
     InstallExtControlledPrefIncognito(ext1_, kPref1,
-                                      Value::CreateStringValue("val2"));
+                                      base::StringValue::New("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(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"));
+    InstallExtControlledPref(ext1_, kPref1, base::StringValue::New("val1"));
     InstallExtControlledPrefIncognitoSessionOnly(
-        ext1_, kPref1, Value::CreateStringValue("val2"));
+        ext1_, kPref1, base::StringValue::New("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"));
+    InstallExtControlledPref(ext1_, kPref1, base::StringValue::New("val1"));
+    InstallExtControlledPref(ext1_, kPref2, base::StringValue::New("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);
   }
@@ skipping 17 matching lines @@
     NotificationObserverMock incognito_observer;
     scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
     PrefChangeRegistrar incognito_registrar;
     incognito_registrar.Init(incog_prefs.get());
     incognito_registrar.Add(kPref1, &incognito_observer);
 
     // Write value and check notification.
     EXPECT_CALL(observer, Observe(_, _, _));
     EXPECT_CALL(incognito_observer, Observe(_, _, _));
     InstallExtControlledPref(ext1_, kPref1,
-        Value::CreateStringValue("https://www.chromium.org"));
+        base::StringValue::New("https://www.chromium.org"));
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     // 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"));
+        base::StringValue::New("https://www.chromium.org"));
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     // Change value.
     EXPECT_CALL(observer, Observe(_, _, _));
     EXPECT_CALL(incognito_observer, Observe(_, _, _));
     InstallExtControlledPref(ext1_, kPref1,
-        Value::CreateStringValue("chrome://newtab"));
+        base::StringValue::New("chrome://newtab"));
     Mock::VerifyAndClearExpectations(&observer);
     Mock::VerifyAndClearExpectations(&incognito_observer);
 
     // Change only incognito persistent value.
     EXPECT_CALL(observer, Observe(_, _, _)).Times(0);
     EXPECT_CALL(incognito_observer, Observe(_, _, _));
     InstallExtControlledPrefIncognito(ext1_, kPref1,
-        Value::CreateStringValue("chrome://newtab2"));
+        base::StringValue::New("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"));
+        base::StringValue::New("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);
   }
   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"));
+    InstallExtControlledPref(ext1_, kPref1, base::StringValue::New("val1"));
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
     prefs()->SetExtensionState(ext1_->id(), 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"));
+    InstallExtControlledPref(ext1_, kPref1, base::StringValue::New("val1"));
     prefs()->SetExtensionState(ext1_->id(), Extension::DISABLED);
     prefs()->SetExtensionState(ext1_->id(), Extension::ENABLED);
   }
   virtual void Verify() {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
   }
 };
 TEST_F(ExtensionPrefsDisableExt,  ExtensionPrefsReenableExt) {}
 
@@ skipping 36 matching lines @@
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
   virtual void Verify() {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}