Remove implicit conversions from scoped_refptr to T* in chrome/browser/prefs/

chrome/browser/prefs/profile_pref_store_manager_unittest.cc

 // Copyright 2014 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/prefs/profile_pref_store_manager.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_enumerator.h"
@@ skipping 73 matching lines @@
 const size_t kReportingIdCount = 3u;
 
 }  // namespace
 
 class ProfilePrefStoreManagerTest : public testing::Test {
  public:
   ProfilePrefStoreManagerTest()
       : configuration_(kConfiguration,
                        kConfiguration + arraysize(kConfiguration)),
         profile_pref_registry_(new user_prefs::PrefRegistrySyncable),
-        registry_verifier_(profile_pref_registry_),
+        registry_verifier_(profile_pref_registry_.get()),

[gab, 2014/08/26 19:29:56]

RegistryVerifier() should take a scoped_refptr as this is what it gets stored as
in the constructor.

         seed_("seed"),
         reset_recorded_(false) {}
 
   virtual void SetUp() OVERRIDE {
     ProfilePrefStoreManager::RegisterPrefs(local_state_.registry());
-    ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_);
+    ProfilePrefStoreManager::RegisterProfilePrefs(profile_pref_registry_.get());
     for (const PrefHashFilter::TrackedPreferenceMetadata* it = kConfiguration;
          it != kConfiguration + arraysize(kConfiguration);
          ++it) {
       if (it->strategy == PrefHashFilter::TRACKING_STRATEGY_ATOMIC) {
         profile_pref_registry_->RegisterStringPref(
             it->name,
             std::string(),
             user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
       } else {
         profile_pref_registry_->RegisterDictionaryPref(
@@ skipping 34 matching lines @@
  protected:
   // Verifies whether a reset was reported via the RecordReset() hook. Also
   // verifies that GetResetTime() was set (or not) accordingly.
   void VerifyResetRecorded(bool reset_expected) {
     EXPECT_EQ(reset_expected, reset_recorded_);
 
     base::PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
     scoped_ptr<PrefService> pref_service(
-        pref_service_factory.Create(profile_pref_registry_));
+        pref_service_factory.Create(profile_pref_registry_.get()));

[gab, 2014/08/26 19:29:56]

PrefServiceFactory::Create() should take a scoped_refptr as this is what it
ultimately gets stored into.

 
     EXPECT_EQ(
         reset_expected,
         !ProfilePrefStoreManager::GetResetTime(pref_service.get()).is_null());
   }
 
   void ClearResetRecorded() {
     reset_recorded_ = false;
 
     base::PrefServiceFactory pref_service_factory;
     pref_service_factory.set_user_prefs(pref_store_);
 
     scoped_ptr<PrefService> pref_service(
-        pref_service_factory.Create(profile_pref_registry_));
+        pref_service_factory.Create(profile_pref_registry_.get()));

[gab, 2014/08/26 19:29:56]

Same as above.

 
     ProfilePrefStoreManager::ClearResetTime(pref_service.get());
   }
 
   void InitializePrefs() {
     // According to the implementation of ProfilePrefStoreManager, this is
     // actually a SegregatedPrefStore backed by two underlying pref stores.
     scoped_refptr<PersistentPrefStore> pref_store =
         manager_->CreateProfilePrefStore(
             main_message_loop_.message_loop_proxy(),
             base::Bind(&ProfilePrefStoreManagerTest::RecordReset,
                        base::Unretained(this)),
             &mock_validation_delegate_);
-    InitializePrefStore(pref_store);
+    InitializePrefStore(pref_store.get());
     pref_store = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
   void DestroyPrefStore() {
-    if (pref_store_) {
+    if (pref_store_.get()) {
       ClearResetRecorded();
       // Force everything to be written to disk, triggering the PrefHashFilter
       // while our RegistryVerifier is watching.
       pref_store_->CommitPendingWrite();
       base::RunLoop().RunUntilIdle();
 
       pref_store_->RemoveObserver(&registry_verifier_);
       pref_store_ = NULL;
       // Nothing should have to happen on the background threads, but just in
       // case...
       base::RunLoop().RunUntilIdle();
     }
   }
 
   void InitializeDeprecatedCombinedProfilePrefStore() {
     scoped_refptr<PersistentPrefStore> pref_store =
         manager_->CreateDeprecatedCombinedProfilePrefStore(
             main_message_loop_.message_loop_proxy());
-    InitializePrefStore(pref_store);
+    InitializePrefStore(pref_store.get());
     pref_store = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
   void InitializePrefStore(PersistentPrefStore* pref_store) {
     pref_store->AddObserver(&registry_verifier_);
     PersistentPrefStore::PrefReadError error = pref_store->ReadPrefs();
     EXPECT_EQ(PersistentPrefStore::PREF_READ_ERROR_NO_FILE, error);
     pref_store->SetValue(kTrackedAtomic, new base::StringValue(kFoobar));
     pref_store->SetValue(kProtectedAtomic, new base::StringValue(kHelloWorld));
@@ skipping 359 matching lines @@
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kHelloWorld);
 
   // Trigger the logic that migrates it back to the unprotected preferences
   // file.
   pref_store_->SetValue(kProtectedAtomic, new base::StringValue(kGoodbyeWorld));
   LoadExistingPrefs();
   ExpectStringValueEquals(kProtectedAtomic, kGoodbyeWorld);
   VerifyResetRecorded(false);
 }