Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/sync/profile_sync_service_password_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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 160 matching lines @@
 
   virtual void SetUp() {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.CreateRequestContext();
     password_store_ = static_cast<MockPasswordStore*>(
         PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse(
             &profile_, MockPasswordStore::Build).get());
   }
 
   virtual void TearDown() {
-    if (password_store_)
+    if (password_store_.get())
       password_store_->ShutdownOnUIThread();
       ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(
           &profile_, NULL);
       profile_.ResetRequestContext();
       AbstractProfileSyncServiceTest::TearDown();
   }
 
   static void SignalEvent(base::WaitableEvent* done) {
     done->Signal();
   }
@@ skipping 28 matching lines @@
       syncer::ModelTypeSet preferred_types =
           sync_service_->GetPreferredDataTypes();
       preferred_types.Put(syncer::PASSWORDS);
       sync_service_->ChangePreferredDataTypes(preferred_types);
       PasswordDataTypeController* data_type_controller =
           new PasswordDataTypeController(sync_service_->factory(),
                                          &profile_,
                                          sync_service_);
       ProfileSyncComponentsFactoryMock* components =
           sync_service_->components_factory_mock();
-      if (password_store_) {
-        EXPECT_CALL(*components, CreatePasswordSyncComponents(_, _, _)).
-            Times(AtLeast(1)).  // Can be more if we hit NEEDS_CRYPTO.
-            WillRepeatedly(MakePasswordSyncComponents(sync_service_,
-                                                      password_store_.get(),
-                                                      data_type_controller));
+      if (password_store_.get()) {
+        EXPECT_CALL(*components, CreatePasswordSyncComponents(_, _, _))
+            .Times(AtLeast(1)).  // Can be more if we hit NEEDS_CRYPTO.
+            WillRepeatedly(MakePasswordSyncComponents(
+                sync_service_, password_store_.get(), data_type_controller));
       } else {
         // When the password store is unavailable, password sync components must
         // not be created.
         EXPECT_CALL(*components, CreatePasswordSyncComponents(_, _, _))
             .Times(0);
       }
       EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _)).
           WillOnce(ReturnNewDataTypeManager());
 
       // We need tokens to get the tests going
@@ skipping 67 matching lines @@
            lhs.username_value == rhs.username_value &&
            lhs.password_element == rhs.password_element &&
            lhs.password_value == rhs.password_value &&
            lhs.ssl_valid == rhs.ssl_valid &&
            lhs.preferred == rhs.preferred &&
            lhs.date_created == rhs.date_created &&
            lhs.blacklisted_by_user == rhs.blacklisted_by_user;
   }
 
   void SetIdleChangeProcessorExpectations() {
-    EXPECT_CALL(*password_store_, AddLoginImpl(_)).Times(0);
-    EXPECT_CALL(*password_store_, UpdateLoginImpl(_)).Times(0);
-    EXPECT_CALL(*password_store_, RemoveLoginImpl(_)).Times(0);
+    EXPECT_CALL(*password_store_.get(), AddLoginImpl(_)).Times(0);
+    EXPECT_CALL(*password_store_.get(), UpdateLoginImpl(_)).Times(0);
+    EXPECT_CALL(*password_store_.get(), RemoveLoginImpl(_)).Times(0);
   }
 
   content::MockNotificationObserver observer_;
   ProfileMock profile_;
   scoped_refptr<MockPasswordStore> password_store_;
   content::NotificationRegistrar registrar_;
 };
 
 void AddPasswordEntriesCallback(ProfileSyncServicePasswordTest* test,
                                 const std::vector<PasswordForm>& entries) {
@@ skipping 34 matching lines @@
       PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse(
           &profile_, NullPasswordStore::Build).get());
   StartSyncService(base::Closure(), base::Closure());
   EXPECT_FALSE(sync_service_->HasUnrecoverableError());
   syncer::ModelTypeSet failed_types =
       sync_service_->failed_datatypes_handler().GetFailedTypes();
   EXPECT_TRUE(failed_types.Equals(syncer::ModelTypeSet(syncer::PASSWORDS)));
 }
 
 TEST_F(ProfileSyncServicePasswordTest, MAYBE_EmptyNativeEmptySync) {
-  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_))
       .WillOnce(Return(true));
-  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(), base::Closure());
   std::vector<PasswordForm> sync_entries;
   GetPasswordEntriesFromSyncDB(&sync_entries);
   EXPECT_EQ(0U, sync_entries.size());
 }
 
 TEST_F(ProfileSyncServicePasswordTest, MAYBE_HasNativeEntriesEmptySync) {
   std::vector<PasswordForm*> forms;
   std::vector<PasswordForm> expected_forms;
   PasswordForm* new_form = new PasswordForm;
   new_form->scheme = PasswordForm::SCHEME_HTML;
   new_form->signon_realm = "pie";
   new_form->origin = GURL("http://pie.com");
   new_form->action = GURL("http://pie.com/submit");
   new_form->username_element = UTF8ToUTF16("name");
   new_form->username_value = UTF8ToUTF16("tom");
   new_form->password_element = UTF8ToUTF16("cork");
   new_form->password_value = UTF8ToUTF16("password1");
   new_form->ssl_valid = true;
   new_form->preferred = false;
   new_form->date_created = base::Time::FromInternalValue(1234);
   new_form->blacklisted_by_user = false;
   forms.push_back(new_form);
   expected_forms.push_back(*new_form);
-  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
-  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(), base::Closure());
   std::vector<PasswordForm> sync_forms;
   GetPasswordEntriesFromSyncDB(&sync_forms);
   ASSERT_EQ(1U, sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[0]));
 }
 
@@ skipping 30 matching lines @@
     new_form->password_element = UTF8ToUTF16("cork");
     new_form->password_value = UTF8ToUTF16("password2");
     new_form->ssl_valid = true;
     new_form->preferred = false;
     new_form->date_created = base::Time::FromInternalValue(1234);
     new_form->blacklisted_by_user = false;
     forms.push_back(new_form);
     expected_forms.push_back(*new_form);
   }
 
-  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true)));
-  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_))
       .WillOnce(Return(true));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(), base::Closure());
   std::vector<PasswordForm> sync_forms;
   GetPasswordEntriesFromSyncDB(&sync_forms);
   ASSERT_EQ(2U, sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[1]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], sync_forms[0]));
 }
@@ skipping 32 matching lines @@
     new_form.password_element = UTF8ToUTF16("cork2");
     new_form.password_value = UTF8ToUTF16("password12");
     new_form.ssl_valid = false;
     new_form.preferred = true;
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     sync_forms.push_back(new_form);
     expected_forms.push_back(new_form);
   }
 
-  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
-  EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
-  EXPECT_CALL(*password_store_, AddLoginImpl(_)).Times(1);
+  EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*password_store_.get(), AddLoginImpl(_)).Times(1);
 
   CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(),
                    base::Bind(&AddPasswordEntriesCallback, this, sync_forms));
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(2U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
@@ skipping 36 matching lines @@
     new_form.password_element = UTF8ToUTF16("cork2");
     new_form.password_value = UTF8ToUTF16("password12");
     new_form.ssl_valid = false;
     new_form.preferred = true;
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     sync_forms.push_back(new_form);
     expected_forms.push_back(new_form);
   }
 
-  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms),
                       AcquireSyncTransaction(this),
                       Return(true)));
-  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
-      .WillOnce(DoAll(AcquireSyncTransaction(this),
-                      Return(true)));
-  EXPECT_CALL(*password_store_, AddLoginImpl(_))
+  EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_))
+      .WillOnce(DoAll(AcquireSyncTransaction(this), Return(true)));
+  EXPECT_CALL(*password_store_.get(), AddLoginImpl(_))
       .WillOnce(AcquireSyncTransaction(this));
 
   CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(),
                    base::Bind(&AddPasswordEntriesCallback, this, sync_forms));
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(2U, new_sync_forms.size());
@@ skipping 50 matching lines @@
     new_form.username_value = UTF8ToUTF16("tom");
     new_form.password_element = UTF8ToUTF16("cork");
     new_form.password_value = UTF8ToUTF16("password12");
     new_form.ssl_valid = false;
     new_form.preferred = true;
     new_form.date_created = base::Time::FromInternalValue(12345);
     new_form.blacklisted_by_user = false;
     expected_forms.push_back(new_form);
   }
 
-  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+  EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true)));
-  EXPECT_CALL(*password_store_, FillBlacklistLogins(_)).WillOnce(Return(true));
-  EXPECT_CALL(*password_store_, UpdateLoginImpl(_)).Times(1);
+  EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*password_store_.get(), UpdateLoginImpl(_)).Times(1);
 
   CreateRootHelper create_root(this, syncer::PASSWORDS);
   StartSyncService(create_root.callback(),
                    base::Bind(&AddPasswordEntriesCallback, this, sync_forms));
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(1U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
 }