Remove //chrome dependency from ExtensionPrefs

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/./extension_prefs_unittest.h"
+#include "chrome/browser/extensions/api/content_settings/content_settings_service.h"
 #include "chrome/browser/extensions/api/preference/preference_api.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/extension.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Value;
 
 namespace extensions {
@@ skipping 11 matching lines @@
 const char kDefaultPref3[] = "default pref 3";
 const char kDefaultPref4[] = "default pref 4";
 
 }  // namespace
 
 // An implementation of the PreferenceAPI which returns the ExtensionPrefs and
 // ExtensionPrefValueMap from the TestExtensionPrefs, rather than from a
 // profile (which we don't create in unittests).
 class TestPreferenceAPI : public PreferenceAPIBase {
  public:
-  explicit TestPreferenceAPI(TestExtensionPrefs* test_extension_prefs)
-      : test_extension_prefs_(test_extension_prefs) { }
-  ~TestPreferenceAPI() { }
+  explicit TestPreferenceAPI(TestExtensionPrefs* test_extension_prefs,
+                             ContentSettingsService* content_settings)
+      : test_extension_prefs_(test_extension_prefs),
+        content_settings_(content_settings) {}
+  ~TestPreferenceAPI() {}
+
  private:
   // PreferenceAPIBase implementation.
   virtual ExtensionPrefs* extension_prefs() OVERRIDE {
     return test_extension_prefs_->prefs();
   }
   virtual ExtensionPrefValueMap* extension_pref_value_map() OVERRIDE {
     return test_extension_prefs_->extension_pref_value_map();
   }
+  virtual scoped_refptr<ContentSettingsStore> content_settings_store()
+      OVERRIDE {
+    return content_settings_->content_settings_store();
+  }
 
   TestExtensionPrefs* test_extension_prefs_;
+  ContentSettingsService* content_settings_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPreferenceAPI);
 };
 
 class ExtensionControlledPrefsTest : public PrefsPrepopulatedTestBase {
  public:
   ExtensionControlledPrefsTest();
   virtual ~ExtensionControlledPrefsTest();
 
   virtual void RegisterPreferences(user_prefs::PrefRegistrySyncable* registry)
       OVERRIDE;
   void InstallExtensionControlledPref(Extension* extension,
                                       const std::string& key,
                                       base::Value* value);
   void InstallExtensionControlledPrefIncognito(Extension* extension,
                                                const std::string& key,
                                                base::Value* value);
   void InstallExtensionControlledPrefIncognitoSessionOnly(
       Extension* extension,
       const std::string& key,
       base::Value* value);
   void InstallExtension(Extension* extension);
   void UninstallExtension(const std::string& extension_id);
 
+  scoped_refptr<ContentSettingsStore> content_settings_store() {
+    return content_settings_->content_settings_store();
+  }
+
  protected:
   void EnsureExtensionInstalled(Extension* extension);
   void EnsureExtensionUninstalled(const std::string& extension_id);
 
+  TestingProfile profile_;
+  ContentSettingsService* content_settings_;
   TestPreferenceAPI test_preference_api_;
 };
 
 ExtensionControlledPrefsTest::ExtensionControlledPrefsTest()
     : PrefsPrepopulatedTestBase(),
-      test_preference_api_(&prefs_) {
+      content_settings_(ContentSettingsService::Get(&profile_)),
+      test_preference_api_(&prefs_, content_settings_) {
+  prefs_.prefs()->AddObserver(content_settings_);
 }
 
 ExtensionControlledPrefsTest::~ExtensionControlledPrefsTest() {
 }
 
 void ExtensionControlledPrefsTest::RegisterPreferences(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(
       kPref1, kDefaultPref1, user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
@@ skipping 153 matching lines @@
 };
 TEST_F(ControlledPrefsInstallIncognitoSessionOnly,
        ControlledPrefsInstallIncognitoSessionOnly) { }
 
 class ControlledPrefsUninstallExtension : public ExtensionControlledPrefsTest {
   virtual void Initialize() OVERRIDE {
     InstallExtensionControlledPref(
         extension1(), kPref1, new base::StringValue("val1"));
     InstallExtensionControlledPref(
         extension1(), kPref2, new base::StringValue("val2"));
-    ContentSettingsStore* store = prefs()->content_settings_store();
+    scoped_refptr<ContentSettingsStore> store = content_settings_store();
     ContentSettingsPattern pattern =
         ContentSettingsPattern::FromString("http://[*.]example.com");
     store->SetExtensionContentSetting(extension1()->id(),
                                       pattern, pattern,
                                       CONTENT_SETTINGS_TYPE_IMAGES,
                                       std::string(),
                                       CONTENT_SETTING_BLOCK,
                                       kExtensionPrefsScopeRegular);
 
     UninstallExtension(extension1()->id());
@@ skipping 186 matching lines @@
       EXPECT_EQ(kDefaultPref1, actual);
     }
   }
 
  private:
   int iteration_;
 };
 TEST_F(ControlledPrefsDisableExtensions, ControlledPrefsDisableExtensions) { }
 
 }  // namespace extensions