ABANDONED: Remove Chrome dependencies from TestExtensionPrefs.

chrome/browser/extensions/extension_prefs_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/prefs/mock_pref_change_callback.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_pref_value_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
-#include "chrome/browser/prefs/pref_service_syncable.h"
-#include "chrome/common/chrome_paths.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/mock_notification_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "sync/api/string_ordinal.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace extensions {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
-ExtensionPrefsTest::ExtensionPrefsTest()
+ExtensionPrefsTest::ExtensionPrefsTest(
+    base::PrefServiceFactory* custom_pref_service_factory)
     : ui_thread_(BrowserThread::UI, &message_loop_),
-      prefs_(message_loop_.message_loop_proxy().get()) {}
+      prefs_(message_loop_.message_loop_proxy().get(),
+             custom_pref_service_factory) {}
 
 ExtensionPrefsTest::~ExtensionPrefsTest() {
 }
 
 void ExtensionPrefsTest::RegisterPreferences(
     user_prefs::PrefRegistrySyncable* registry) {}
 
 void ExtensionPrefsTest::SetUp() {
   RegisterPreferences(prefs_.pref_registry().get());
   Initialize();
 }
 
 void ExtensionPrefsTest::TearDown() {
   Verify();
 
   // Reset ExtensionPrefs, and re-verify.
   prefs_.ResetPrefRegistry();
   RegisterPreferences(prefs_.pref_registry().get());
   prefs_.RecreateExtensionPrefs();
   Verify();
   prefs_.pref_service()->CommitPendingWrite();
   message_loop_.RunUntilIdle();
 }
 
 // Tests the LastPingDay/SetLastPingDay functions.
 class ExtensionPrefsLastPingDay : public ExtensionPrefsTest {
  public:
   ExtensionPrefsLastPingDay()
-      : extension_time_(Time::Now() - TimeDelta::FromHours(4)),
+      : ExtensionPrefsTest(NULL),
+        extension_time_(Time::Now() - TimeDelta::FromHours(4)),
         blacklist_time_(Time::Now() - TimeDelta::FromHours(2)) {}
 
   virtual void Initialize() OVERRIDE {
     extension_id_ = prefs_.AddExtensionAndReturnId("last_ping_day");
     EXPECT_TRUE(prefs()->LastPingDay(extension_id_).is_null());
     prefs()->SetLastPingDay(extension_id_, extension_time_);
     prefs()->SetBlacklistLastPingDay(blacklist_time_);
   }
 
   virtual void Verify() OVERRIDE {
     Time result = prefs()->LastPingDay(extension_id_);
     EXPECT_FALSE(result.is_null());
     EXPECT_TRUE(result == extension_time_);
     result = prefs()->BlacklistLastPingDay();
     EXPECT_FALSE(result.is_null());
     EXPECT_TRUE(result == blacklist_time_);
   }
 
  private:
   Time extension_time_;
   Time blacklist_time_;
   std::string extension_id_;
 };
 TEST_F(ExtensionPrefsLastPingDay, LastPingDay) {}
 
 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsToolbarOrder() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     list_.push_back(prefs_.AddExtensionAndReturnId("1"));
     list_.push_back(prefs_.AddExtensionAndReturnId("2"));
     list_.push_back(prefs_.AddExtensionAndReturnId("3"));
     ExtensionIdList before_list = prefs()->GetToolbarOrder();
     EXPECT_TRUE(before_list.empty());
     prefs()->SetToolbarOrder(list_);
   }
 
   virtual void Verify() OVERRIDE {
     ExtensionIdList result = prefs()->GetToolbarOrder();
     ASSERT_EQ(list_, result);
   }
 
  private:
   ExtensionIdList list_;
 };
 TEST_F(ExtensionPrefsToolbarOrder, ToolbarOrder) {}
 
 // Tests the GetKnownDisabled/SetKnownDisabled functions.
 class ExtensionPrefsKnownDisabled : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsKnownDisabled() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     ExtensionIdSet before_set;
     EXPECT_FALSE(prefs()->GetKnownDisabled(&before_set));
     EXPECT_TRUE(before_set.empty());
 
     // Initialize to an empty list and confirm that GetKnownDisabled() returns
     // true and an empty list.
     prefs()->SetKnownDisabled(before_set);
     EXPECT_TRUE(prefs()->GetKnownDisabled(&before_set));
     EXPECT_TRUE(before_set.empty());
@@ skipping 11 matching lines @@
   }
 
  private:
   ExtensionIdSet set_;
 };
 TEST_F(ExtensionPrefsKnownDisabled, KnownDisabled) {}
 
 // Tests the IsExtensionDisabled/SetExtensionState functions.
 class ExtensionPrefsExtensionState : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsExtensionState() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     extension = prefs_.AddExtension("test");
     prefs()->SetExtensionState(extension->id(), Extension::DISABLED);
   }
 
   virtual void Verify() OVERRIDE {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsExtensionState, ExtensionState) {}
 
 class ExtensionPrefsEscalatePermissions : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsEscalatePermissions() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     extension = prefs_.AddExtension("test");
     prefs()->SetDidExtensionEscalatePermissions(extension.get(), true);
   }
 
   virtual void Verify() OVERRIDE {
     EXPECT_TRUE(prefs()->DidExtensionEscalatePermissions(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsEscalatePermissions, EscalatePermissions) {}
 
 // Tests the AddGrantedPermissions / GetGrantedPermissions functions.
 class ExtensionPrefsGrantedPermissions : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsGrantedPermissions() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     const APIPermissionInfo* permission_info =
       PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
     api_perm_set1_.insert(APIPermission::kTab);
     api_perm_set1_.insert(APIPermission::kBookmark);
     scoped_ptr<APIPermission> permission(
         permission_info->CreateAPIPermission());
@@ skipping 133 matching lines @@
   APIPermissionSet api_permissions_;
   URLPatternSet ehost_permissions_;
   URLPatternSet shost_permissions_;
   URLPatternSet effective_permissions_;
 };
 TEST_F(ExtensionPrefsGrantedPermissions, GrantedPermissions) {}
 
 // Tests the SetActivePermissions / GetActivePermissions functions.
 class ExtensionPrefsActivePermissions : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsActivePermissions() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     extension_id_ = prefs_.AddExtensionAndReturnId("test");
 
     APIPermissionSet api_perms;
     api_perms.insert(APIPermission::kTab);
     api_perms.insert(APIPermission::kBookmark);
     api_perms.insert(APIPermission::kHistory);
 
     ManifestPermissionSet empty_manifest_permissions;
 
@@ skipping 31 matching lines @@
 
  private:
   std::string extension_id_;
   scoped_refptr<PermissionSet> active_perms_;
 };
 TEST_F(ExtensionPrefsActivePermissions, SetAndGetActivePermissions) {}
 
 // Tests the GetVersionString function.
 class ExtensionPrefsVersionString : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsVersionString() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     extension = prefs_.AddExtension("test");
     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
     prefs()->OnExtensionUninstalled(extension->id(),
                                     Manifest::INTERNAL, false);
   }
 
   virtual void Verify() OVERRIDE {
     EXPECT_EQ("", prefs()->GetVersionString(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsVersionString, VersionString) {}
 
 class ExtensionPrefsAcknowledgment : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsAcknowledgment() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     not_installed_id_ = "pghjnghklobnfoidcldiidjjjhkeeaoi";
 
     // Install some extensions.
     for (int i = 0; i < 5; i++) {
       std::string name = "test" + base::IntToString(i);
       extensions_.push_back(prefs_.AddExtension(name));
     }
     EXPECT_EQ(NULL,
               prefs()->GetInstalledExtensionInfo(not_installed_id_).get());
@@ skipping 44 matching lines @@
 
   std::string not_installed_id_;
   std::string external_id_;
   std::string blacklisted_id_;
 };
 TEST_F(ExtensionPrefsAcknowledgment, Acknowledgment) {}
 
 // Tests the idle install information functions.
 class ExtensionPrefsDelayedInstallInfo : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsDelayedInstallInfo() : ExtensionPrefsTest(NULL) {}
+
   // Sets idle install information for one test extension.
   void SetIdleInfo(std::string id, int num) {
     DictionaryValue manifest;
     manifest.SetString(manifest_keys::kName, "test");
     manifest.SetString(manifest_keys::kVersion, "1." + base::IntToString(num));
     base::FilePath path =
         prefs_.extensions_dir().AppendASCII(base::IntToString(num));
     std::string errors;
     scoped_refptr<Extension> extension = Extension::Create(
         path, Manifest::INTERNAL, manifest, Extension::NO_FLAGS, id, &errors);
@@ skipping 21 matching lines @@
   bool HasInfoForId(ExtensionPrefs::ExtensionsInfo* info,
                     const std::string& id) {
     for (size_t i = 0; i < info->size(); ++i) {
       if (info->at(i)->extension_id == id)
         return true;
     }
     return false;
   }
 
   virtual void Initialize() OVERRIDE {
-    PathService::Get(chrome::DIR_TEST_DATA, &basedir_);
     now_ = Time::Now();
     id1_ = prefs_.AddExtensionAndReturnId("1");
     id2_ = prefs_.AddExtensionAndReturnId("2");
     id3_ = prefs_.AddExtensionAndReturnId("3");
     id4_ = prefs_.AddExtensionAndReturnId("4");
 
     // Set info for two extensions, then remove it.
     SetIdleInfo(id1_, 1);
     SetIdleInfo(id2_, 2);
     VerifyIdleInfo(id1_, 1);
@@ skipping 39 matching lines @@
     VerifyIdleInfo(id1_, 1);
     VerifyIdleInfo(id2_, 2);
     VerifyIdleInfo(id4_, 4);
 
     // Make sure there isn't info the for the one extension id we removed.
     EXPECT_FALSE(prefs()->GetDelayedInstallInfo(id3_));
   }
 
  protected:
   Time now_;
-  base::FilePath basedir_;
   std::string id1_;
   std::string id2_;
   std::string id3_;
   std::string id4_;
 };
 TEST_F(ExtensionPrefsDelayedInstallInfo, DelayedInstallInfo) {}
 
 // Tests the FinishDelayedInstallInfo function.
 class ExtensionPrefsFinishDelayedInstallInfo : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsFinishDelayedInstallInfo() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     DictionaryValue dictionary;
     dictionary.SetString(manifest_keys::kName, "test");
     dictionary.SetString(manifest_keys::kVersion, "0.1");
     dictionary.SetString(manifest_keys::kBackgroundPage, "background.html");
     scoped_refptr<Extension> extension =
         prefs_.AddExtensionWithManifest(dictionary, Manifest::INTERNAL);
     id_ = extension->id();
 
 
@@ skipping 38 matching lines @@
     EXPECT_EQ(1u, scripts->GetSize());
   }
 
  protected:
   std::string id_;
 };
 TEST_F(ExtensionPrefsFinishDelayedInstallInfo, FinishDelayedInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsOnExtensionInstalled() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::DISABLED,
                                   false,
                                   syncer::StringOrdinal());
   }
 
   virtual void Verify() OVERRIDE {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsOnExtensionInstalled,
        ExtensionPrefsOnExtensionInstalled) {}
 
 class ExtensionPrefsAppDraggedByUser : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsAppDraggedByUser() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     extension_ = prefs_.AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->WasAppDraggedByUser(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(),
                                   Extension::ENABLED,
                                   false,
                                   syncer::StringOrdinal());
   }
 
   virtual void Verify() OVERRIDE {
     // Set the flag and see if it persisted.
     prefs()->SetAppDraggedByUser(extension_->id());
     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
 
     // Make sure it doesn't change on consecutive calls.
     prefs()->SetAppDraggedByUser(extension_->id());
     EXPECT_TRUE(prefs()->WasAppDraggedByUser(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsAppDraggedByUser, ExtensionPrefsAppDraggedByUser) {}
 
 class ExtensionPrefsFlags : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsFlags() : ExtensionPrefsTest(NULL) {}
+
   virtual void Initialize() OVERRIDE {
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(manifest_keys::kName, "from_webstore");
       dictionary.SetString(manifest_keys::kVersion, "0.1");
       webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
           dictionary, Manifest::INTERNAL, Extension::FROM_WEBSTORE);
     }
 
     {
@@ skipping 25 matching lines @@
     EXPECT_TRUE(prefs()->WasInstalledByDefault(default_extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> webstore_extension_;
   scoped_refptr<Extension> bookmark_extension_;
   scoped_refptr<Extension> default_extension_;
 };
 TEST_F(ExtensionPrefsFlags, ExtensionPrefsFlags) {}
 
-PrefsPrepopulatedTestBase::PrefsPrepopulatedTestBase()
-    : ExtensionPrefsTest() {
+PrefsPrepopulatedTestBase::PrefsPrepopulatedTestBase(
+    base::PrefServiceFactory* custom_pref_service_factory)
+    : ExtensionPrefsTest(custom_pref_service_factory) {
   DictionaryValue simple_dict;
   std::string error;
 
   simple_dict.SetString(manifest_keys::kVersion, "1.0.0.0");
   simple_dict.SetString(manifest_keys::kName, "unused");
 
   extension1_ = Extension::Create(
       prefs_.temp_dir().AppendASCII("ext1_"),
       Manifest::EXTERNAL_PREF,
       simple_dict,
@@ skipping 21 matching lines @@
   for (size_t i = 0; i < kNumInstalledExtensions; ++i)
     installed_[i] = false;
 }
 
 PrefsPrepopulatedTestBase::~PrefsPrepopulatedTestBase() {
 }
 
 // Tests that blacklist state can be queried.
 class ExtensionPrefsBlacklistedExtensions : public ExtensionPrefsTest {
  public:
+  ExtensionPrefsBlacklistedExtensions() : ExtensionPrefsTest(NULL) {}
   virtual ~ExtensionPrefsBlacklistedExtensions() {}
 
   virtual void Initialize() OVERRIDE {
     extension_a_ = prefs_.AddExtension("a");
     extension_b_ = prefs_.AddExtension("b");
     extension_c_ = prefs_.AddExtension("c");
   }
 
   virtual void Verify() OVERRIDE {
     {
@@ skipping 57 matching lines @@
 
  private:
   scoped_refptr<const Extension> extension_a_;
   scoped_refptr<const Extension> extension_b_;
   scoped_refptr<const Extension> extension_c_;
 };
 TEST_F(ExtensionPrefsBlacklistedExtensions,
        ExtensionPrefsBlacklistedExtensions) {}
 
 }  // namespace extensions