Do not observe MessageLoop destruction from ModelSafeWorker.

components/browser_sync/profile_sync_test_util.cc

 // Copyright 2016 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 "components/browser_sync/profile_sync_test_util.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_model_worker.h"
+#include "components/history/core/browser/history_service.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync/base/sync_prefs.h"
 #include "components/sync/driver/glue/browser_thread_model_worker.h"
 #include "components/sync/driver/glue/ui_model_worker.h"
 #include "components/sync/driver/signin_manager_wrapper.h"
 #include "components/sync/engine/passive_model_worker.h"
 #include "net/url_request/url_request_test_util.h"
 
 namespace browser_sync {
@@ skipping 18 matching lines @@
 
   ~BundleSyncClient() override;
 
   PrefService* GetPrefService() override;
   sync_sessions::SyncSessionsClient* GetSyncSessionsClient() override;
   autofill::PersonalDataManager* GetPersonalDataManager() override;
   base::WeakPtr<syncer::SyncableService> GetSyncableServiceForType(
       syncer::ModelType type) override;
   syncer::SyncService* GetSyncService() override;
   scoped_refptr<syncer::ModelSafeWorker> CreateModelWorkerForGroup(
-      syncer::ModelSafeGroup group,
-      syncer::WorkerLoopDestructionObserver* observer) override;
+      syncer::ModelSafeGroup group) override;
   history::HistoryService* GetHistoryService() override;
   bookmarks::BookmarkModel* GetBookmarkModel() override;
 
  private:
   PrefService* const pref_service_;
   sync_sessions::SyncSessionsClient* const sync_sessions_client_;
   autofill::PersonalDataManager* const personal_data_manager_;
   const base::Callback<base::WeakPtr<syncer::SyncableService>(
       syncer::ModelType type)>
       get_syncable_service_callback_;
@@ skipping 53 matching lines @@
   return get_syncable_service_callback_.Run(type);
 }
 
 syncer::SyncService* BundleSyncClient::GetSyncService() {
   if (get_sync_service_callback_.is_null())
     return syncer::FakeSyncClient::GetSyncService();
   return get_sync_service_callback_.Run();
 }
 
 scoped_refptr<syncer::ModelSafeWorker>
-BundleSyncClient::CreateModelWorkerForGroup(
-    syncer::ModelSafeGroup group,
-    syncer::WorkerLoopDestructionObserver* observer) {
+BundleSyncClient::CreateModelWorkerForGroup(syncer::ModelSafeGroup group) {
   if (!db_thread_)
-    return FakeSyncClient::CreateModelWorkerForGroup(group, observer);
+    return FakeSyncClient::CreateModelWorkerForGroup(group);
   DCHECK(file_thread_) << "DB thread was specified but FILE thread was not.";
   switch (group) {
     case syncer::GROUP_DB:
-      return new syncer::BrowserThreadModelWorker(db_thread_, syncer::GROUP_DB,
-                                                  observer);
+      return new syncer::BrowserThreadModelWorker(db_thread_, syncer::GROUP_DB);
     case syncer::GROUP_FILE:
       return new syncer::BrowserThreadModelWorker(file_thread_,
-                                                  syncer::GROUP_FILE, observer);
+                                                  syncer::GROUP_FILE);
     case syncer::GROUP_UI:
-      return new syncer::UIModelWorker(base::ThreadTaskRunnerHandle::Get(),
-                                       observer);
+      return new syncer::UIModelWorker(base::ThreadTaskRunnerHandle::Get());
     case syncer::GROUP_PASSIVE:
-      return new syncer::PassiveModelWorker(observer);
+      return new syncer::PassiveModelWorker();
     case syncer::GROUP_HISTORY: {
       history::HistoryService* history_service = GetHistoryService();
       if (!history_service)
         return nullptr;
       return new HistoryModelWorker(history_service->AsWeakPtr(),
-                                    base::ThreadTaskRunnerHandle::Get(),
-                                    observer);
+                                    base::ThreadTaskRunnerHandle::Get());
     }
     default:
       return nullptr;
   }
 }
 
 history::HistoryService* BundleSyncClient::GetHistoryService() {
   if (history_service_)
     return history_service_;
   return FakeSyncClient::GetHistoryService();
@@ skipping 106 matching lines @@
   init_params.debug_identifier = "dummyDebugName";
   init_params.channel = version_info::Channel::UNKNOWN;
   init_params.db_thread = db_thread_;
   init_params.file_thread = base::ThreadTaskRunnerHandle::Get();
   init_params.blocking_pool = worker_pool_owner_.pool().get();
 
   return init_params;
 }
 
 }  // namespace browser_sync