Moved JsonPrefStore to use SequencedWorkerPool

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 "extension_prefs_unittest.h"
 
 #include "base/basictypes.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
@@ skipping 35 matching lines @@
 namespace extensions {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
 ExtensionPrefsTest::ExtensionPrefsTest()
     : ui_thread_(BrowserThread::UI, &message_loop_),
       file_thread_(BrowserThread::FILE, &message_loop_) {
+  prefs_.reset(new TestExtensionPrefs(message_loop_.message_loop_proxy()));
 }
 
-ExtensionPrefsTest::~ExtensionPrefsTest() {}
+ExtensionPrefsTest::~ExtensionPrefsTest() {
+  prefs_.reset(NULL);
+}
 
 void ExtensionPrefsTest::RegisterPreferences() {}
 
 void ExtensionPrefsTest::SetUp() {
   RegisterPreferences();
   Initialize();
 }
 
 void ExtensionPrefsTest::TearDown() {
   Verify();
 
   // Reset ExtensionPrefs, and re-verify.
-  prefs_.RecreateExtensionPrefs();
+  prefs_->RecreateExtensionPrefs();
   RegisterPreferences();
   Verify();
+  prefs_->pref_service()->CommitPendingWrite();
+  message_loop_.RunAllPending();
 }
 
 // Tests the LastPingDay/SetLastPingDay functions.
 class ExtensionPrefsLastPingDay : public ExtensionPrefsTest {
  public:
   ExtensionPrefsLastPingDay()
       : extension_time_(Time::Now() - TimeDelta::FromHours(4)),
         blacklist_time_(Time::Now() - TimeDelta::FromHours(2)) {}
 
   virtual void Initialize() {
-    extension_id_ = prefs_.AddExtensionAndReturnId("last_ping_day");
+    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() {
     Time result = prefs()->LastPingDay(extension_id_);
     EXPECT_FALSE(result.is_null());
     EXPECT_TRUE(result == extension_time_);
     result = prefs()->BlacklistLastPingDay();
@@ skipping 17 matching lines @@
   permission.has_permission = has_access;
   vector->push_back(permission);
 }
 
 }  // namspace
 
 // Test the MediaGalleries permissions functions.
 class MediaGalleriesPermissions : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    extension1_id_ = prefs_.AddExtensionAndReturnId("test1");
-    extension2_id_ = prefs_.AddExtensionAndReturnId("test2");
-    extension3_id_ = prefs_.AddExtensionAndReturnId("test3");
+    extension1_id_ = prefs_->AddExtensionAndReturnId("test1");
+    extension2_id_ = prefs_->AddExtensionAndReturnId("test2");
+    extension3_id_ = prefs_->AddExtensionAndReturnId("test3");
     // Id4 isn't used to ensure that an empty permission list is ok.
-    extension4_id_ = prefs_.AddExtensionAndReturnId("test4");
+    extension4_id_ = prefs_->AddExtensionAndReturnId("test4");
     Verify();
 
     prefs()->SetMediaGalleryPermission(extension1_id_, 1, false);
     AddGalleryPermission(1, false, &extension1_expectation_);
     Verify();
 
     prefs()->SetMediaGalleryPermission(extension1_id_, 2, true);
     AddGalleryPermission(2, true, &extension1_expectation_);
     Verify();
 
@@ skipping 59 matching lines @@
   std::vector<chrome::MediaGalleryPermission> extension2_expectation_;
   std::vector<chrome::MediaGalleryPermission> extension3_expectation_;
   std::vector<chrome::MediaGalleryPermission> extension4_expectation_;
 };
 TEST_F(MediaGalleriesPermissions, MediaGalleries) {}
 
 // Tests the GetToolbarOrder/SetToolbarOrder functions.
 class ExtensionPrefsToolbarOrder : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    list_.push_back(prefs_.AddExtensionAndReturnId("1"));
-    list_.push_back(prefs_.AddExtensionAndReturnId("2"));
-    list_.push_back(prefs_.AddExtensionAndReturnId("3"));
+    list_.push_back(prefs_->AddExtensionAndReturnId("1"));
+    list_.push_back(prefs_->AddExtensionAndReturnId("2"));
+    list_.push_back(prefs_->AddExtensionAndReturnId("3"));
     std::vector<std::string> before_list = prefs()->GetToolbarOrder();
     EXPECT_TRUE(before_list.empty());
     prefs()->SetToolbarOrder(list_);
   }
 
   virtual void Verify() {
     std::vector<std::string> result = prefs()->GetToolbarOrder();
     ASSERT_EQ(list_.size(), result.size());
     for (size_t i = 0; i < list_.size(); i++) {
       EXPECT_EQ(list_[i], result[i]);
     }
   }
 
  private:
   std::vector<std::string> list_;
 };
 TEST_F(ExtensionPrefsToolbarOrder, ToolbarOrder) {}
 
 
 // Tests the IsExtensionDisabled/SetExtensionState functions.
 class ExtensionPrefsExtensionState : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    extension = prefs_.AddExtension("test");
+    extension = prefs_->AddExtension("test");
     prefs()->SetExtensionState(extension->id(), Extension::DISABLED);
   }
 
   virtual void Verify() {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsExtensionState, ExtensionState) {}
 
 
 class ExtensionPrefsEscalatePermissions : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    extension = prefs_.AddExtension("test");
+    extension = prefs_->AddExtension("test");
     prefs()->SetDidExtensionEscalatePermissions(extension.get(), true);
   }
 
   virtual void Verify() {
     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:
   virtual void Initialize() {
     const APIPermissionInfo* permission_info =
       PermissionsInfo::GetInstance()->GetByID(APIPermission::kSocket);
 
-    extension_id_ = prefs_.AddExtensionAndReturnId("test");
+    extension_id_ = prefs_->AddExtensionAndReturnId("test");
 
     api_perm_set1_.insert(APIPermission::kTab);
     api_perm_set1_.insert(APIPermission::kBookmark);
     scoped_ptr<APIPermission> permission(
         permission_info->CreateAPIPermission());
     {
       scoped_ptr<ListValue> value(new ListValue());
       value->Append(Value::CreateStringValue("tcp-connect:*.example.com:80"));
       value->Append(Value::CreateStringValue("udp-bind::8080"));
       value->Append(Value::CreateStringValue("udp-send-to::8888"));
@@ skipping 127 matching lines @@
   URLPatternSet ehost_permissions_;
   URLPatternSet shost_permissions_;
   URLPatternSet effective_permissions_;
 };
 TEST_F(ExtensionPrefsGrantedPermissions, GrantedPermissions) {}
 
 // Tests the SetActivePermissions / GetActivePermissions functions.
 class ExtensionPrefsActivePermissions : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    extension_id_ = prefs_.AddExtensionAndReturnId("test");
+    extension_id_ = prefs_->AddExtensionAndReturnId("test");
 
     APIPermissionSet api_perms;
     api_perms.insert(APIPermission::kTab);
     api_perms.insert(APIPermission::kBookmark);
     api_perms.insert(APIPermission::kHistory);
 
     URLPatternSet ehosts;
     AddPattern(&ehosts, "http://*.google.com/*");
     AddPattern(&ehosts, "http://example.com/*");
     AddPattern(&ehosts, "chrome://favicon/*");
@@ skipping 27 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:
   virtual void Initialize() {
-    extension = prefs_.AddExtension("test");
+    extension = prefs_->AddExtension("test");
     EXPECT_EQ("0.1", prefs()->GetVersionString(extension->id()));
     prefs()->OnExtensionUninstalled(extension->id(),
                                     Extension::INTERNAL, false);
   }
 
   virtual void Verify() {
     EXPECT_EQ("", prefs()->GetVersionString(extension->id()));
   }
 
  private:
   scoped_refptr<Extension> extension;
 };
 TEST_F(ExtensionPrefsVersionString, VersionString) {}
 
 // Tests various areas of blacklist functionality.
 class ExtensionPrefsBlacklist : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     not_installed_id_ = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 
     // Install 5 extensions.
     for (int i = 0; i < 5; i++) {
       std::string name = "test" + base::IntToString(i);
-      extensions_.push_back(prefs_.AddExtension(name));
+      extensions_.push_back(prefs_->AddExtension(name));
     }
     EXPECT_EQ(NULL, prefs()->GetInstalledExtensionInfo(not_installed_id_));
 
     ExtensionList::const_iterator iter;
     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
       EXPECT_TRUE(prefs()->UserMayLoad(*iter, NULL));
     }
     // Blacklist one installed and one not-installed extension id.
     std::set<std::string> blacklisted_ids;
     blacklisted_ids.insert(extensions_[0]->id());
@@ skipping 31 matching lines @@
 TEST_F(ExtensionPrefsBlacklist, Blacklist) {}
 
 class ExtensionPrefsAcknowledgment : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     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));
+      extensions_.push_back(prefs_->AddExtension(name));
     }
     EXPECT_EQ(NULL, prefs()->GetInstalledExtensionInfo(not_installed_id_));
 
     ExtensionList::const_iterator iter;
     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
       std::string id = (*iter)->id();
       EXPECT_FALSE(prefs()->IsExternalExtensionAcknowledged(id));
       EXPECT_FALSE(prefs()->IsBlacklistedExtensionAcknowledged(id));
       EXPECT_FALSE(prefs()->IsOrphanedExtensionAcknowledged(id));
       if (external_id_.empty()) {
@@ skipping 54 matching lines @@
 };
 TEST_F(ExtensionPrefsAcknowledgment, Acknowledgment) {}
 
 // Tests force hiding browser actions.
 class ExtensionPrefsHidingBrowserActions : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
     // Install 5 extensions.
     for (int i = 0; i < 5; i++) {
       std::string name = "test" + base::IntToString(i);
-      extensions_.push_back(prefs_.AddExtension(name));
+      extensions_.push_back(prefs_->AddExtension(name));
     }
 
     ExtensionList::const_iterator iter;
     for (iter = extensions_.begin(); iter != extensions_.end(); ++iter)
       EXPECT_TRUE(prefs()->GetBrowserActionVisibility(*iter));
 
     prefs()->SetBrowserActionVisibility(extensions_[0], false);
     prefs()->SetBrowserActionVisibility(extensions_[1], true);
   }
 
@@ skipping 36 matching lines @@
                                             &fetch_time));
     ASSERT_EQ(crx_path.value(),
               basedir_.AppendASCII(base::IntToString(num)).value());
     ASSERT_EQ("1." + base::IntToString(num), version);
     ASSERT_TRUE(fetch_time == now_ + TimeDelta::FromSeconds(num));
   }
 
   virtual void Initialize() {
     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");
+    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);
     VerifyIdleInfo(id2_, 2);
     std::set<std::string> ids = prefs()->GetIdleInstallInfoIds();
     EXPECT_EQ(2u, ids.size());
     EXPECT_TRUE(ContainsKey(ids, id1_));
     EXPECT_TRUE(ContainsKey(ids, id2_));
@@ skipping 43 matching lines @@
   std::string id1_;
   std::string id2_;
   std::string id3_;
   std::string id4_;
 };
 TEST_F(ExtensionPrefsIdleInstallInfo, IdleInstallInfo) {}
 
 class ExtensionPrefsOnExtensionInstalled : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    extension_ = prefs_.AddExtension("on_extension_installed");
+    extension_ = prefs_->AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->IsExtensionDisabled(extension_->id()));
     prefs()->OnExtensionInstalled(
         extension_.get(), Extension::DISABLED,
         syncer::StringOrdinal());
   }
 
   virtual void Verify() {
     EXPECT_TRUE(prefs()->IsExtensionDisabled(extension_->id()));
   }
 
  private:
   scoped_refptr<Extension> extension_;
 };
 TEST_F(ExtensionPrefsOnExtensionInstalled,
        ExtensionPrefsOnExtensionInstalled) {}
 
 class ExtensionPrefsAppDraggedByUser : public ExtensionPrefsTest {
  public:
   virtual void Initialize() {
-    extension_ = prefs_.AddExtension("on_extension_installed");
+    extension_ = prefs_->AddExtension("on_extension_installed");
     EXPECT_FALSE(prefs()->WasAppDraggedByUser(extension_->id()));
     prefs()->OnExtensionInstalled(extension_.get(), Extension::ENABLED,
                                   syncer::StringOrdinal());
   }
 
   virtual void Verify() {
     // 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:
   virtual void Initialize() {
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName, "from_webstore");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
-      webstore_extension_ = prefs_.AddExtensionWithManifestAndFlags(
+      webstore_extension_ = prefs_->AddExtensionWithManifestAndFlags(
           dictionary, Extension::INTERNAL, Extension::FROM_WEBSTORE);
     }
 
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName, "from_bookmark");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
-      bookmark_extension_ = prefs_.AddExtensionWithManifestAndFlags(
+      bookmark_extension_ = prefs_->AddExtensionWithManifestAndFlags(
           dictionary, Extension::INTERNAL, Extension::FROM_BOOKMARK);
     }
 
     {
       base::DictionaryValue dictionary;
       dictionary.SetString(extension_manifest_keys::kName,
                            "was_installed_by_default");
       dictionary.SetString(extension_manifest_keys::kVersion, "0.1");
-      default_extension_ = prefs_.AddExtensionWithManifestAndFlags(
+      default_extension_ = prefs_->AddExtensionWithManifestAndFlags(
           dictionary,
           Extension::INTERNAL,
           Extension::WAS_INSTALLED_BY_DEFAULT);
     }
   }
 
   virtual void Verify() {
     EXPECT_TRUE(prefs()->IsFromWebStore(webstore_extension_->id()));
     EXPECT_FALSE(prefs()->IsFromBookmark(webstore_extension_->id()));
 
@@ skipping 19 matching lines @@
       ext3_(NULL),
       ext4_(NULL),
       installed() {
   DictionaryValue simple_dict;
   std::string error;
 
   simple_dict.SetString(keys::kVersion, "1.0.0.0");
   simple_dict.SetString(keys::kName, "unused");
 
   ext1_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext1_"), Extension::EXTERNAL_PREF,
+      prefs_->temp_dir().AppendASCII("ext1_"), Extension::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
   ext2_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext2_"), Extension::EXTERNAL_PREF,
+      prefs_->temp_dir().AppendASCII("ext2_"), Extension::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
   ext3_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext3_"), Extension::EXTERNAL_PREF,
+      prefs_->temp_dir().AppendASCII("ext3_"), Extension::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
   ext4_scoped_ = Extension::Create(
-      prefs_.temp_dir().AppendASCII("ext4_"), Extension::EXTERNAL_PREF,
+      prefs_->temp_dir().AppendASCII("ext4_"), Extension::EXTERNAL_PREF,
       simple_dict, Extension::NO_FLAGS, &error);
 
   ext1_ = ext1_scoped_.get();
   ext2_ = ext2_scoped_.get();
   ext3_ = ext3_scoped_.get();
   ext4_ = ext4_scoped_.get();
 
   for (size_t i = 0; i < arraysize(installed); ++i)
     installed[i] = false;
 }
@@ skipping 89 matching lines @@
 TEST_F(ExtensionPrefsInstallOneExtension, ExtensionPrefsInstallOneExtension) {}
 
 // Check that we do not forget persistent incognito values after a reload.
 class ExtensionPrefsInstallIncognitoPersistent
     : public ExtensionPrefsPrepopulatedTest {
  public:
   virtual void Initialize() {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     InstallExtControlledPrefIncognito(ext1_, kPref1,
                                       Value::CreateStringValue("val2"));
-    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    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());
+    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 ExtensionPrefsPrepopulatedTest {
  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());
+    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());
+    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_;
 };
@@ skipping 35 matching lines @@
     using testing::_;
     using testing::Mock;
     using testing::StrEq;
 
     content::MockNotificationObserver observer;
     PrefChangeRegistrar registrar;
     registrar.Init(prefs()->pref_service());
     registrar.Add(kPref1, &observer);
 
     content::MockNotificationObserver incognito_observer;
-    scoped_ptr<PrefService> incog_prefs(prefs_.CreateIncognitoPrefService());
+    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"));
     Mock::VerifyAndClearExpectations(&observer);
@@ skipping 105 matching lines @@
     InstallExtControlledPrefIncognito(ext1_, kPref1, v1i);
     testing::Mock::VerifyAndClearExpectations(v1);
     testing::Mock::VerifyAndClearExpectations(v1i);
     // Make sure there is no memory leak and both values are deleted.
     EXPECT_CALL(*v1, Die()).Times(1);
     EXPECT_CALL(*v1i, Die()).Times(1);
     EXPECT_CALL(*v2, Die()).Times(1);
     EXPECT_CALL(*v2i, Die()).Times(1);
     InstallExtControlledPref(ext1_, kPref1, v2);
     InstallExtControlledPrefIncognito(ext1_, kPref1, v2i);
-    prefs_.RecreateExtensionPrefs();
+    prefs_->RecreateExtensionPrefs();
     testing::Mock::VerifyAndClearExpectations(v1);
     testing::Mock::VerifyAndClearExpectations(v1i);
     testing::Mock::VerifyAndClearExpectations(v2);
     testing::Mock::VerifyAndClearExpectations(v2i);
   }
 
   virtual void Verify() {
   }
 };
 TEST_F(ExtensionPrefsSetExtensionControlledPref,
     ExtensionPrefsSetExtensionControlledPref) {}
 
 // Tests that the switches::kDisableExtensions command-line flag prevents
 // extension controlled preferences from being enacted.
 class ExtensionPrefsDisableExtensions : public ExtensionPrefsPrepopulatedTest {
  public:
   ExtensionPrefsDisableExtensions()
       : iteration_(0) {}
   virtual ~ExtensionPrefsDisableExtensions() {}
   virtual void Initialize() {
     InstallExtControlledPref(ext1_, kPref1, Value::CreateStringValue("val1"));
     // This becomes only active in the second verification phase.
-    prefs_.set_extensions_disabled(true);
+    prefs_->set_extensions_disabled(true);
   }
   virtual void Verify() {
     std::string actual = prefs()->pref_service()->GetString(kPref1);
     if (iteration_ == 0) {
       EXPECT_EQ("val1", actual);
       ++iteration_;
     } else {
       EXPECT_EQ(kDefaultPref1, actual);
     }
   }
@@ skipping 64 matching lines @@
     EXPECT_EQ(string16(), error16);
     EXPECT_TRUE(prefs()->UserMayModifySettings(extension_.get(), &error16));
     EXPECT_EQ(string16(), error16);
     EXPECT_FALSE(prefs()->MustRemainEnabled(extension_.get(), &error16));
     EXPECT_EQ(string16(), error16);
   }
 };
 TEST_F(ExtensionPrefsNotRequiredExtension, NotRequiredExtension) {}
 
 }  // namespace extensions