[Sync] Convert DTCs to be not RefCounted and NonThreadSafe.

components/sync_sessions/session_data_type_controller_unittest.cc

Index: components/sync_sessions/session_data_type_controller_unittest.cc
diff --git a/components/sync_sessions/session_data_type_controller_unittest.cc b/components/sync_sessions/session_data_type_controller_unittest.cc
index 0909d84ec98e042a51a773c986adde3922a959ac..693c3091bc20118244f04231bd647fc2656dd03c 100644
--- a/components/sync_sessions/session_data_type_controller_unittest.cc
+++ b/components/sync_sessions/session_data_type_controller_unittest.cc
@@ -4,6 +4,8 @@
 
 #include "components/sync_sessions/session_data_type_controller.h"
 
+#include <set>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ -99,8 +101,7 @@ class SessionDataTypeControllerTest : public testing::Test,
   SessionDataTypeControllerTest()
       : sync_driver::FakeSyncClient(&profile_sync_factory_),
         load_finished_(false),
-        last_type_(syncer::UNSPECIFIED),
-        weak_ptr_factory_(this) {}
+        last_type_(syncer::UNSPECIFIED) {}
   ~SessionDataTypeControllerTest() override {}
 
   // FakeSyncClient overrides.
@@ -125,30 +126,22 @@ class SessionDataTypeControllerTest : public testing::Test,
         "cache_guid", "Wayne Gretzky's Hacking Box", "Chromium 10k",
         "Chrome 10k", sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id"));
 
-    controller_ = new SessionDataTypeController(
-        base::ThreadTaskRunnerHandle::Get(), base::Bind(&base::DoNothing), this,
-        local_device_.get(), kSavingBrowserHistoryDisabled);
+    controller_.reset(new SessionDataTypeController(
+        base::Bind(&base::DoNothing), this, local_device_.get(),
+        kSavingBrowserHistoryDisabled));
 
     load_finished_ = false;
     last_type_ = syncer::UNSPECIFIED;
     last_error_ = syncer::SyncError();
   }
 
-  void TearDown() override {
-    controller_ = NULL;
-    local_device_.reset();
-    synced_window_getter_.reset();
-    synced_window_delegate_.reset();
-    sync_sessions_client_.reset();
-  }
-
   void Start() {
     controller_->LoadModels(
         base::Bind(&SessionDataTypeControllerTest::OnLoadFinished,
-                   weak_ptr_factory_.GetWeakPtr()));
+                   base::Unretained(this)));
   }
 
-  void OnLoadFinished(syncer::ModelType type, syncer::SyncError error) {
+  void OnLoadFinished(syncer::ModelType type, const syncer::SyncError& error) {
     load_finished_ = true;
     last_type_ = type;
     last_error_ = error;
@@ -174,6 +167,10 @@ class SessionDataTypeControllerTest : public testing::Test,
     return testing::AssertionSuccess();
   }
 
+  bool load_finished() const { return load_finished_; }
+  LocalDeviceInfoProviderMock* local_device() { return local_device_.get(); }
+  SessionDataTypeController* controller() { return controller_.get(); }
+
  protected:
   void SetSessionRestoreInProgress(bool is_restore_in_progress) {
     synced_window_delegate_->SetSessionRestoreInProgress(
@@ -183,92 +180,91 @@ class SessionDataTypeControllerTest : public testing::Test,
       controller_->OnSessionRestoreComplete();
   }
 
-  scoped_refptr<SessionDataTypeController> controller_;
-  std::unique_ptr<MockSyncedWindowDelegatesGetter> synced_window_getter_;
-  std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
-  std::unique_ptr<MockSyncedWindowDelegate> synced_window_delegate_;
-  std::unique_ptr<TestSyncSessionsClient> sync_sessions_client_;
-  bool load_finished_;
-
  private:
   base::MessageLoop message_loop_;
   TestingPrefServiceSimple prefs_;
+  std::unique_ptr<MockSyncedWindowDelegate> synced_window_delegate_;
+  std::unique_ptr<MockSyncedWindowDelegatesGetter> synced_window_getter_;
   SyncApiComponentFactoryMock profile_sync_factory_;
+  std::unique_ptr<TestSyncSessionsClient> sync_sessions_client_;
+  std::unique_ptr<LocalDeviceInfoProviderMock> local_device_;
+  std::unique_ptr<SessionDataTypeController> controller_;
+
+  bool load_finished_;
   syncer::ModelType last_type_;
   syncer::SyncError last_error_;
-  base::WeakPtrFactory<SessionDataTypeControllerTest> weak_ptr_factory_;
 };
 
 TEST_F(SessionDataTypeControllerTest, StartModels) {
   Start();
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller_->state());
+            controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest, StartModelsDelayedByLocalDevice) {
-  local_device_->SetInitialized(false);
+  local_device()->SetInitialized(false);
   Start();
-  EXPECT_FALSE(load_finished_);
+  EXPECT_FALSE(load_finished());
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller_->state());
+            controller()->state());
 
-  local_device_->SetInitialized(true);
+  local_device()->SetInitialized(true);
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller_->state());
+            controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest, StartModelsDelayedByRestoreInProgress) {
   SetSessionRestoreInProgress(true);
   Start();
-  EXPECT_FALSE(load_finished_);
+  EXPECT_FALSE(load_finished());
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller_->state());
+            controller()->state());
 
   SetSessionRestoreInProgress(false);
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller_->state());
+            controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest,
        StartModelsDelayedByLocalDeviceThenRestoreInProgress) {
-  local_device_->SetInitialized(false);
+  local_device()->SetInitialized(false);
   SetSessionRestoreInProgress(true);
   Start();
-  EXPECT_FALSE(load_finished_);
+  EXPECT_FALSE(load_finished());
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller_->state());
+            controller()->state());
 
-  local_device_->SetInitialized(true);
-  EXPECT_FALSE(load_finished_);
+  local_device()->SetInitialized(true);
+  EXPECT_FALSE(load_finished());
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller_->state());
+            controller()->state());
 
   SetSessionRestoreInProgress(false);
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller_->state());
+            controller()->state());
   EXPECT_TRUE(LoadResult());
 }
 
 TEST_F(SessionDataTypeControllerTest,
        StartModelsDelayedByRestoreInProgressThenLocalDevice) {
-  local_device_->SetInitialized(false);
+  local_device()->SetInitialized(false);
   SetSessionRestoreInProgress(true);
   Start();
-  EXPECT_FALSE(load_finished_);
+  EXPECT_FALSE(load_finished());
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller_->state());
+            controller()->state());
 
   SetSessionRestoreInProgress(false);
-  EXPECT_FALSE(load_finished_);
+  EXPECT_FALSE(load_finished());
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_STARTING,
-            controller_->state());
+            controller()->state());
 
-  local_device_->SetInitialized(true);
+  local_device()->SetInitialized(true);
   EXPECT_EQ(sync_driver::DataTypeController::MODEL_LOADED,
-            controller_->state());
+            controller()->state());
   EXPECT_TRUE(LoadResult());
 }