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

chrome/browser/sync/glue/non_ui_data_type_controller_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/sync/glue/non_ui_data_type_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 171 matching lines @@
                   &done));
     done.TimedWait(TestTimeouts::action_timeout());
     if (!done.IsSignaled()) {
       ADD_FAILURE() << "Timed out waiting for DB thread to finish.";
     }
     base::MessageLoop::current()->RunUntilIdle();
   }
 
  protected:
   void SetStartExpectations() {
-    EXPECT_CALL(*dtc_mock_, StartModels()).WillOnce(Return(true));
+    EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true));
     EXPECT_CALL(model_load_callback_, Run(_, _));
     EXPECT_CALL(*profile_sync_factory_,
                 CreateSharedChangeProcessor()).
         WillOnce(Return(change_processor_.get()));
   }
 
   void SetAssociateExpectations() {
-    EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-        WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
-    EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
-        WillOnce(Return(true));
-    EXPECT_CALL(*change_processor_, ActivateDataType(_));
-    EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
-        WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
-    EXPECT_CALL(*change_processor_, GetSyncData(_)).
-        WillOnce(Return(syncer::SyncError()));
-    EXPECT_CALL(*change_processor_, GetSyncCount()).WillOnce(Return(0));
-    EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
+    EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+        .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
+    EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
+        .WillOnce(Return(true));
+    EXPECT_CALL(*change_processor_.get(), ActivateDataType(_));
+    EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
+        .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
+    EXPECT_CALL(*change_processor_.get(), GetSyncData(_))
+        .WillOnce(Return(syncer::SyncError()));
+    EXPECT_CALL(*change_processor_.get(), GetSyncCount()).WillOnce(Return(0));
+    EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_));
   }
 
   void SetActivateExpectations(DataTypeController::StartResult result) {
     EXPECT_CALL(start_callback_, Run(result,_,_));
   }
 
   void SetStopExpectations() {
-    EXPECT_CALL(*dtc_mock_, StopModels());
-    EXPECT_CALL(*change_processor_, Disconnect()).WillOnce(Return(true));
+    EXPECT_CALL(*dtc_mock_.get(), StopModels());
+    EXPECT_CALL(*change_processor_.get(), Disconnect()).WillOnce(Return(true));
     EXPECT_CALL(service_, DeactivateDataType(_));
   }
 
   void SetStartFailExpectations(DataTypeController::StartResult result) {
-    EXPECT_CALL(*dtc_mock_, StopModels()).Times(AtLeast(1));
+    EXPECT_CALL(*dtc_mock_.get(), StopModels()).Times(AtLeast(1));
     if (DataTypeController::IsUnrecoverableResult(result))
-      EXPECT_CALL(*dtc_mock_, RecordUnrecoverableError(_, _));
-    EXPECT_CALL(*dtc_mock_, RecordStartFailure(result));
-    EXPECT_CALL(start_callback_, Run(result,_,_));
+      EXPECT_CALL(*dtc_mock_.get(), RecordUnrecoverableError(_, _));
+    EXPECT_CALL(*dtc_mock_.get(), RecordStartFailure(result));
+    EXPECT_CALL(start_callback_, Run(result, _, _));
   }
 
   void Start() {
     non_ui_dtc_->LoadModels(
         base::Bind(&ModelLoadCallbackMock::Run,
                    base::Unretained(&model_load_callback_)));
     non_ui_dtc_->StartAssociating(
         base::Bind(&StartCallbackMock::Run,
                    base::Unretained(&start_callback_)));
   }
@@ skipping 23 matching lines @@
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest, StartFirstRun) {
   SetStartExpectations();
-  EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-      WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
-  EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
-      WillOnce(Return(true));
-  EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
-      WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true)));
-  EXPECT_CALL(*change_processor_, GetSyncData(_)).
-      WillOnce(Return(syncer::SyncError()));
-  EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+      .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
+  EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
+      .WillOnce(Return(true));
+  EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(false), Return(true)));
+  EXPECT_CALL(*change_processor_.get(), GetSyncData(_))
+      .WillOnce(Return(syncer::SyncError()));
+  EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_));
   SetActivateExpectations(DataTypeController::OK_FIRST_RUN);
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 }
 
 // Start the DTC and have StartModels() return false.  Then, stop the
 // DTC without finishing model startup.  It should stop cleanly.
 TEST_F(SyncNonUIDataTypeControllerTest, AbortDuringStartModels) {
   EXPECT_CALL(*profile_sync_factory_,
               CreateSharedChangeProcessor()).
       WillOnce(Return(change_processor_.get()));
-  EXPECT_CALL(*dtc_mock_, StartModels()).WillOnce(Return(false));
-  EXPECT_CALL(*dtc_mock_, StopModels());
+  EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(false));
+  EXPECT_CALL(*dtc_mock_.get(), StopModels());
   EXPECT_CALL(model_load_callback_, Run(_, _));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   non_ui_dtc_->LoadModels(
       base::Bind(&ModelLoadCallbackMock::Run,
                  base::Unretained(&model_load_callback_)));
   WaitForDTC();
   EXPECT_EQ(DataTypeController::MODEL_STARTING, non_ui_dtc_->state());
   non_ui_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 // Start the DTC and have MergeDataAndStartSyncing() return an error.
 // The DTC should become disabled, and the DTC should still stop
 // cleanly.
 TEST_F(SyncNonUIDataTypeControllerTest, StartAssociationFailed) {
   SetStartExpectations();
-  EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-      WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
-  EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
-      WillOnce(Return(true));
-  EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
-      WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
-  EXPECT_CALL(*change_processor_, GetSyncData(_)).
-      WillOnce(Return(syncer::SyncError()));
-  EXPECT_CALL(*dtc_mock_, RecordAssociationTime(_));
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+      .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
+  EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
+      .WillOnce(Return(true));
+  EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(true), Return(true)));
+  EXPECT_CALL(*change_processor_.get(), GetSyncData(_))
+      .WillOnce(Return(syncer::SyncError()));
+  EXPECT_CALL(*dtc_mock_.get(), RecordAssociationTime(_));
   SetStartFailExpectations(DataTypeController::ASSOCIATION_FAILED);
   // Set up association to fail with an association failed error.
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   syncable_service_.set_merge_data_and_start_syncing_error(
       syncer::SyncError(FROM_HERE,
                         "Sync Error", non_ui_dtc_->type()));
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::DISABLED, non_ui_dtc_->state());
   non_ui_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest,
        StartAssociationTriggersUnrecoverableError) {
   SetStartExpectations();
   SetStartFailExpectations(DataTypeController::UNRECOVERABLE_ERROR);
   // Set up association to fail with an unrecoverable error.
-  EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-      WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
-  EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
-      WillRepeatedly(Return(true));
-  EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
-      WillRepeatedly(DoAll(SetArgumentPointee<0>(false), Return(false)));
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+      .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
+  EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
+      .WillRepeatedly(DoAll(SetArgumentPointee<0>(false), Return(false)));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest,
        StartAssociationCryptoNotReady) {
   SetStartExpectations();
   SetStartFailExpectations(DataTypeController::NEEDS_CRYPTO);
   // Set up association to fail with a NEEDS_CRYPTO error.
-  EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-      WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
-  EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
-      WillRepeatedly(Return(false));
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+      .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
+  EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
+      .WillRepeatedly(Return(false));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 // Trigger a Stop() call when we check if the model associator has user created
 // nodes.
 TEST_F(SyncNonUIDataTypeControllerTest, AbortDuringAssociation) {
   WaitableEvent wait_for_db_thread_pause(false, false);
   WaitableEvent pause_db_thread(false, false);
 
   SetStartExpectations();
   SetStartFailExpectations(DataTypeController::ABORTED);
-  EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-      WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
-  EXPECT_CALL(*change_processor_, CryptoReadyIfNecessary()).
-      WillOnce(Return(true));
-  EXPECT_CALL(*change_processor_, SyncModelHasUserCreatedNodes(_)).
-      WillOnce(DoAll(
-          SignalEvent(&wait_for_db_thread_pause),
-          WaitOnEvent(&pause_db_thread),
-          SetArgumentPointee<0>(true),
-          Return(true)));
-  EXPECT_CALL(*change_processor_, GetSyncData(_)).
-      WillOnce(
-          Return(
-              syncer::SyncError(FROM_HERE, "Disconnected.", AUTOFILL_PROFILE)));
-  EXPECT_CALL(*change_processor_, Disconnect()).
-      WillOnce(DoAll(SignalEvent(&pause_db_thread), Return(true)));
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+      .WillOnce(GetWeakPtrToSyncableService(&syncable_service_));
+  EXPECT_CALL(*change_processor_.get(), CryptoReadyIfNecessary())
+      .WillOnce(Return(true));
+  EXPECT_CALL(*change_processor_.get(), SyncModelHasUserCreatedNodes(_))
+      .WillOnce(DoAll(SignalEvent(&wait_for_db_thread_pause),
+                      WaitOnEvent(&pause_db_thread),
+                      SetArgumentPointee<0>(true),
+                      Return(true)));
+  EXPECT_CALL(*change_processor_.get(), GetSyncData(_)).WillOnce(
+      Return(syncer::SyncError(FROM_HERE, "Disconnected.", AUTOFILL_PROFILE)));
+  EXPECT_CALL(*change_processor_.get(), Disconnect())
+      .WillOnce(DoAll(SignalEvent(&pause_db_thread), Return(true)));
   EXPECT_CALL(service_, DeactivateDataType(_));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   wait_for_db_thread_pause.Wait();
   non_ui_dtc_->Stop();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 // Start the DTC while the backend tasks are blocked. Then stop the DTC before
 // the backend tasks get a chance to run. The DTC should have no interaction
 // with the profile sync factory or profile sync service once stopped.
 TEST_F(SyncNonUIDataTypeControllerTest, StartAfterSyncShutdown) {
   non_ui_dtc_->BlockBackendTasks();
 
   SetStartExpectations();
   // We don't expect StopSyncing to be called because local_service_ will never
   // have been set.
-  EXPECT_CALL(*change_processor_, Disconnect()).WillOnce(Return(true));
-  EXPECT_CALL(*dtc_mock_, StopModels());
+  EXPECT_CALL(*change_processor_.get(), Disconnect()).WillOnce(Return(true));
+  EXPECT_CALL(*dtc_mock_.get(), StopModels());
   EXPECT_CALL(service_, DeactivateDataType(_));
-  EXPECT_CALL(*dtc_mock_, RecordStartFailure(DataTypeController::ABORTED));
+  EXPECT_CALL(*dtc_mock_.get(),
+              RecordStartFailure(DataTypeController::ABORTED));
   EXPECT_CALL(start_callback_, Run(DataTypeController::ABORTED, _, _));
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   non_ui_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Mock::VerifyAndClearExpectations(&profile_sync_factory_);
   Mock::VerifyAndClearExpectations(&service_);
-  Mock::VerifyAndClearExpectations(change_processor_);
-  Mock::VerifyAndClearExpectations(dtc_mock_);
+  Mock::VerifyAndClearExpectations(change_processor_.get());
+  Mock::VerifyAndClearExpectations(dtc_mock_.get());
 
-  EXPECT_CALL(*change_processor_, Connect(_,_,_,_,_)).
-      WillOnce(Return(base::WeakPtr<syncer::SyncableService>()));
+  EXPECT_CALL(*change_processor_.get(), Connect(_, _, _, _, _))
+      .WillOnce(Return(base::WeakPtr<syncer::SyncableService>()));
   non_ui_dtc_->UnblockBackendTasks();
   WaitForDTC();
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest, Stop) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
   SetStopExpectations();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
@@ skipping 30 matching lines @@
 
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 }
 
 TEST_F(SyncNonUIDataTypeControllerTest,
        OnSingleDatatypeUnrecoverableError) {
   SetStartExpectations();
   SetAssociateExpectations();
   SetActivateExpectations(DataTypeController::OK);
-  EXPECT_CALL(*dtc_mock_, RecordUnrecoverableError(_, "Test"));
-  EXPECT_CALL(service_, DisableBrokenDatatype(_,_,_)).WillOnce(
-      InvokeWithoutArgs(non_ui_dtc_.get(),
-                        &NonUIDataTypeController::Stop));
+  EXPECT_CALL(*dtc_mock_.get(), RecordUnrecoverableError(_, "Test"));
+  EXPECT_CALL(service_, DisableBrokenDatatype(_, _, _)).WillOnce(
+      InvokeWithoutArgs(non_ui_dtc_.get(), &NonUIDataTypeController::Stop));
   SetStopExpectations();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
   // This should cause non_ui_dtc_->Stop() to be called.
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, base::Bind(
       &NonUIDataTypeControllerFake::
           OnSingleDatatypeUnrecoverableError,
       non_ui_dtc_.get(),
       FROM_HERE,
       std::string("Test")));
   WaitForDTC();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, non_ui_dtc_->state());
 }
 
 }  // namespace
 
 }  // namespace browser_sync