[Sync] Replace manual DI with SetTestingFactory.

chrome/browser/ui/webui/sync_internals_message_handler.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/ui/webui/sync_internals_message_handler.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 41 matching lines @@
       return integer;
   }
   return 0;
 }
 
 }  //  namespace
 
 SyncInternalsMessageHandler::SyncInternalsMessageHandler()
     : SyncInternalsMessageHandler(
           base::BindRepeating(
-              &SyncInternalsMessageHandler::BindForSyncServiceProvider,
-              base::Unretained(this)),
-          base::BindRepeating(
               &syncer::sync_ui_util::ConstructAboutInformation)) {}
 
 SyncInternalsMessageHandler::SyncInternalsMessageHandler(
-    SyncServiceProvider sync_service_provider,
     AboutSyncDataDelegate about_sync_data_delegate)
-    : sync_service_provider_(std::move(sync_service_provider)),
-      about_sync_data_delegate_(std::move(about_sync_data_delegate)),
+    : about_sync_data_delegate_(std::move(about_sync_data_delegate)),
       weak_ptr_factory_(this) {}
 
 SyncInternalsMessageHandler::~SyncInternalsMessageHandler() {
   UnregisterModelNotifications();
 }
 
 void SyncInternalsMessageHandler::OnJavascriptDisallowed() {
   // Invaliding weak ptrs works well here because the only weak ptr we vend is
   // to the sync side to give us information that should be used to populate the
   // javascript side. If javascript is disallowed, we don't care about updating
@@ skipping 43 matching lines @@
 }
 
 void SyncInternalsMessageHandler::HandleRegisterForEvents(
     const ListValue* args) {
   DCHECK(args->empty());
   AllowJavascript();
 
   // is_registered_ flag protects us from double-registering.  This could
   // happen on a page refresh, where the JavaScript gets re-run but the
   // message handler remains unchanged.
-  SyncService* service = sync_service_provider_.Run();
+  SyncService* service = GetSyncService();
   if (service && !is_registered_) {
     service->AddObserver(this);
     service->AddProtocolEventObserver(this);
     js_controller_ = service->GetJsController();
     js_controller_->AddJsEventHandler(this);
     is_registered_ = true;
   }
 }
 
 void SyncInternalsMessageHandler::HandleRegisterForPerTypeCounters(
     const ListValue* args) {
   DCHECK(args->empty());
   AllowJavascript();
 
-  SyncService* service = sync_service_provider_.Run();
+  SyncService* service = GetSyncService();
   if (!service)
     return;
 
   if (!is_registered_for_counters_) {
     service->AddTypeDebugInfoObserver(this);
     is_registered_for_counters_ = true;
   } else {
     // Re-register to ensure counters get re-emitted.
     service->RemoveTypeDebugInfoObserver(this);
     service->AddTypeDebugInfoObserver(this);
@@ skipping 24 matching lines @@
 }
 
 void SyncInternalsMessageHandler::HandleGetAllNodes(const ListValue* args) {
   DCHECK_EQ(1U, args->GetSize());
   AllowJavascript();
 
   int request_id = 0;
   bool success = ExtractIntegerValue(args, &request_id);
   DCHECK(success);
 
-  SyncService* service = sync_service_provider_.Run();
+  SyncService* service = GetSyncService();
   if (service) {
     // This opens up the possibility of non-javascript code calling us
     // asynchronously, and potentially at times we're not allowed to call into
     // the javascript side. We guard against this by invalidating this weak ptr
     // should javascript become disallowed.
     service->GetAllNodes(
         base::Bind(&SyncInternalsMessageHandler::OnReceivedAllNodes,
                    weak_ptr_factory_.GetWeakPtr(), request_id));
   }
 }
@@ skipping 71 matching lines @@
 
 void SyncInternalsMessageHandler::HandleJsEvent(
     const std::string& name,
     const JsEventDetails& details) {
   DVLOG(1) << "Handling event: " << name
            << " with details " << details.ToString();
   DispatchEvent(name, details.Get());
 }
 
 void SyncInternalsMessageHandler::SendAboutInfo() {
-  std::unique_ptr<DictionaryValue> value = about_sync_data_delegate_.Run(
-      sync_service_provider_.Run(), chrome::GetChannel());
+  std::unique_ptr<DictionaryValue> value =
+      about_sync_data_delegate_.Run(GetSyncService(), chrome::GetChannel());
   DispatchEvent(syncer::sync_ui_util::kOnAboutInfoUpdated, *value);
 }
 
-SyncService* SyncInternalsMessageHandler::BindForSyncServiceProvider() {
+SyncService* SyncInternalsMessageHandler::GetSyncService() {
   return ProfileSyncServiceFactory::GetForProfile(
       Profile::FromWebUI(web_ui())->GetOriginalProfile());
 }
 
 void SyncInternalsMessageHandler::DispatchEvent(const std::string& name,
                                                 const Value& details_value) {
   CallJavascriptFunction(syncer::sync_ui_util::kDispatchEvent, Value(name),
                          details_value);
 }
 
 void SyncInternalsMessageHandler::UnregisterModelNotifications() {
-  SyncService* service = sync_service_provider_.Run();
+  SyncService* service = GetSyncService();
   if (!service)
     return;
 
   // Cannot use ScopedObserver to do all the tracking because most don't follow
   // AddObserver/RemoveObserver method naming style.
   if (is_registered_) {
     DCHECK(js_controller_);
     service->RemoveObserver(this);
     service->RemoveProtocolEventObserver(this);
     js_controller_->RemoveJsEventHandler(this);
     js_controller_ = nullptr;
     is_registered_ = false;
   }
 
   if (is_registered_for_counters_) {
     service->RemoveTypeDebugInfoObserver(this);
     is_registered_for_counters_ = false;
   }
 }