ABANDONED: Remove Chrome dependencies from TestExtensionPrefs.

chrome/browser/extensions/api/preference/preference_api_prefs_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/mock_pref_change_callback.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/preference/preference_api.h"
+#include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_prefs_unittest.h"
+#include "chrome/browser/prefs/pref_service_mock_factory.h"
+#include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "extensions/common/extension.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Value;
 
 namespace extensions {
 
 namespace {
@@ skipping 50 matching lines @@
       Extension* extension,
       const std::string& key,
       base::Value* value);
   void InstallExtension(Extension* extension);
   void UninstallExtension(const std::string& extension_id);
 
  protected:
   void EnsureExtensionInstalled(Extension* extension);
   void EnsureExtensionUninstalled(const std::string& extension_id);
 
+  // Creates a new incognito PrefService from |test_extension_prefs_|.
+  scoped_ptr<PrefService> CreateIncognitoPrefService();
+
   TestPreferenceAPI test_preference_api_;
 };
 
 ExtensionControlledPrefsTest::ExtensionControlledPrefsTest()
-    : PrefsPrepopulatedTestBase(),
+    : PrefsPrepopulatedTestBase(new PrefServiceMockFactory),
       test_preference_api_(&prefs_) {
 }
 
 ExtensionControlledPrefsTest::~ExtensionControlledPrefsTest() {
 }
 
 void ExtensionControlledPrefsTest::RegisterPreferences(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(
       kPref1, kDefaultPref1, user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
@@ skipping 68 matching lines @@
                               extension4() };
   for (size_t i = 0; i < kNumInstalledExtensions; ++i) {
     if (extensions[i]->id() == extension_id) {
       installed_[i] = false;
       break;
     }
   }
   prefs()->OnExtensionUninstalled(extension_id, Manifest::INTERNAL, false);
 }
 
+scoped_ptr<PrefService>
+ExtensionControlledPrefsTest::CreateIncognitoPrefService() {
+  // This downcast is safe due to the PrefServiceMockFactory that was passed to
+  // TestExtensionPrefs by way of PrefsPrepopulatedTestBase.
+  PrefServiceSyncable* pref_service =
+      static_cast<PrefServiceSyncable*>(prefs_.pref_service());
+  return scoped_ptr<PrefService>(pref_service->CreateIncognitoPrefService(
+      new ExtensionPrefStore(prefs_.extension_pref_value_map(), true))).Pass();
+}
+
 class ControlledPrefsInstallOneExtension
     : public ExtensionControlledPrefsTest {
   virtual void Initialize() OVERRIDE {
     InstallExtensionControlledPref(extension1(),
                                    kPref1,
                                    new base::StringValue("val1"));
   }
   virtual void Verify() OVERRIDE {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     EXPECT_EQ("val1", actual);
   }
 };
 TEST_F(ControlledPrefsInstallOneExtension,
        ControlledPrefsInstallOneExtension) { }
 
 // Check that we do not forget persistent incognito values after a reload.
 class ControlledPrefsInstallIncognitoPersistent
     : public ExtensionControlledPrefsTest {
  public:
   virtual void Initialize() OVERRIDE {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     InstallExtensionControlledPrefIncognito(
         extension1(), kPref1, new base::StringValue("val2"));
-    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    scoped_ptr<PrefService> incog_prefs(CreateIncognitoPrefService());
     std::string actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
 
   virtual void Verify() OVERRIDE {
     // 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());
+    scoped_ptr<PrefService> incog_prefs(CreateIncognitoPrefService());
     actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
 };
 TEST_F(ControlledPrefsInstallIncognitoPersistent,
        ControlledPrefsInstallIncognitoPersistent) { }
 
 // Check that we forget 'session only' incognito values after a reload.
 class ControlledPrefsInstallIncognitoSessionOnly
     : public ExtensionControlledPrefsTest {
  public:
   ControlledPrefsInstallIncognitoSessionOnly() : iteration_(0) {}
 
   virtual void Initialize() OVERRIDE {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     InstallExtensionControlledPrefIncognitoSessionOnly(
         extension1(), kPref1, new base::StringValue("val2"));
-    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    scoped_ptr<PrefService> incog_prefs(CreateIncognitoPrefService());
     std::string actual = incog_prefs->GetString(kPref1);
     EXPECT_EQ("val2", actual);
   }
   virtual void Verify() OVERRIDE {
     // 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());
+    scoped_ptr<PrefService> incog_prefs(CreateIncognitoPrefService());
     actual = incog_prefs->GetString(kPref1);
     if (iteration_ == 0) {
       EXPECT_EQ("val2", actual);
     } else {
       EXPECT_EQ("val1", actual);
     }
     ++iteration_;
   }
   int iteration_;
 };
@@ skipping 37 matching lines @@
     using testing::_;
     using testing::Mock;
     using testing::StrEq;
 
     MockPrefChangeCallback observer(prefs()->pref_service());
     PrefChangeRegistrar registrar;
     registrar.Init(prefs()->pref_service());
     registrar.Add(kPref1, observer.GetCallback());
 
     MockPrefChangeCallback incognito_observer(prefs()->pref_service());
-    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    scoped_ptr<PrefService> incog_prefs(CreateIncognitoPrefService());
     PrefChangeRegistrar incognito_registrar;
     incognito_registrar.Init(incog_prefs.get());
     incognito_registrar.Add(kPref1, incognito_observer.GetCallback());
 
     // Write value and check notification.
     EXPECT_CALL(observer, OnPreferenceChanged(_));
     EXPECT_CALL(incognito_observer, OnPreferenceChanged(_));
     InstallExtensionControlledPref(extension1(), kPref1,
         new base::StringValue("https://www.chromium.org"));
     Mock::VerifyAndClearExpectations(&observer);
@@ skipping 148 matching lines @@
       EXPECT_EQ(kDefaultPref1, actual);
     }
   }
 
  private:
   int iteration_;
 };
 TEST_F(ControlledPrefsDisableExtensions, ControlledPrefsDisableExtensions) { }
 
 }  // namespace extensions