[Sync] Remove some http-related chrome deps from SyncBackendHostImpl.

chrome/browser/sync/profile_sync_service.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/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/time/time.h"
 #include "build/build_config.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/about_signin_internals_factory.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/sync_backend_host_impl.h"
 #include "chrome/browser/sync/glue/sync_start_util.h"
 #include "chrome/browser/sync/sessions/notification_service_sessions_router.h"
 #include "chrome/browser/sync/supervised_user_signin_manager_wrapper.h"
 #include "chrome/browser/sync/sync_type_preference_provider.h"
 #include "chrome/browser/ui/sync/browser_synced_window_delegates_getter.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
 #include "components/invalidation/impl/profile_invalidation_provider.h"
 #include "components/invalidation/public/invalidation_service.h"
+#include "components/network_time/network_time_tracker.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/about_signin_internals.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/browser/signin_metrics.h"
 #include "components/sync_driver/backend_migrator.h"
 #include "components/sync_driver/change_processor.h"
 #include "components/sync_driver/data_type_controller.h"
 #include "components/sync_driver/device_info.h"
@@ skipping 119 matching lines @@
 
 // Perform the actual sync data folder deletion.
 // This should only be called on the sync thread.
 void DeleteSyncDataFolder(const base::FilePath& directory_path) {
   if (base::DirectoryExists(directory_path)) {
     if (!base::DeleteFile(directory_path, true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
+void UpdateNetworkTimeOnUIThread(base::Time network_time,

[Nicolas Zea, 2015/10/27 20:41:42]

Were you planning to try to move this to the PSSFactory?

[maxbogue, 2015/10/27 23:53:08]

Done.

+                                 base::TimeDelta resolution,
+                                 base::TimeDelta latency,
+                                 base::TimeTicks post_time) {
+  g_browser_process->network_time_tracker()->UpdateNetworkTime(
+      network_time, resolution, latency, post_time);
+}
+
+void UpdateNetworkTime(
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
+    const base::Time& network_time,
+    const base::TimeDelta& resolution,
+    const base::TimeDelta& latency) {
+  ui_thread->PostTask(FROM_HERE,
+                      base::Bind(&UpdateNetworkTimeOnUIThread, network_time,
+                                 resolution, latency, base::TimeTicks::Now()));
+}
+
 }  // anonymous namespace
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error) {
   return (error.action != syncer::UNKNOWN_ACTION &&
           error.action != syncer::DISABLE_SYNC_ON_CLIENT &&
           error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT &&
           error.action != syncer::DISABLE_SYNC_AND_ROLLBACK &&
           error.action != syncer::ROLLBACK_DONE &&
           error.action != syncer::RESET_LOCAL_SYNC_DATA);
@@ skipping 319 matching lines @@
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_) {
     NOTREACHED();
     return;
   }
 
   SyncCredentials credentials = GetCredentials();
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter(
-      profile_->GetRequestContext());
-
   if (backend_mode_ == SYNC && delete_stale_data)
     ClearStaleErrors();
 
-  backend_->Initialize(this, sync_thread_.Pass(),
-                       content::BrowserThread::GetMessageLoopProxyForThread(
-                           content::BrowserThread::DB),
-                       content::BrowserThread::GetMessageLoopProxyForThread(
-                           content::BrowserThread::FILE),
-                       GetJsEventHandler(), sync_service_url_,
-                       local_device_->GetSyncUserAgent(), credentials,
-                       delete_stale_data,
-                       scoped_ptr<syncer::SyncManagerFactory>(
-                           new syncer::SyncManagerFactory(GetManagerType()))
-                           .Pass(),
-                       MakeWeakHandle(weak_factory_.GetWeakPtr()),
-                       base::Bind(browser_sync::ChromeReportUnrecoverableError,
-                                  chrome::GetChannel()),
-                       network_resources_.get(), saved_nigori_state_.Pass());
+  SyncBackendHost::HttpPostProviderFactoryGetter
+      get_http_post_provider_factory = base::Bind(
+          &syncer::NetworkResources::GetHttpPostProviderFactory,
+          base::Unretained(network_resources_.get()),
+          make_scoped_refptr(profile_->GetRequestContext()),
+          base::Bind(&UpdateNetworkTime,
+                     content::BrowserThread::GetMessageLoopProxyForThread(
+                         content::BrowserThread::UI)));
+
+  backend_->Initialize(
+      this, sync_thread_.Pass(),
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::DB),
+      content::BrowserThread::GetMessageLoopProxyForThread(
+          content::BrowserThread::FILE),
+      GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
+      credentials, delete_stale_data,
+      scoped_ptr<syncer::SyncManagerFactory>(
+          new syncer::SyncManagerFactory(GetManagerType()))
+          .Pass(),
+      MakeWeakHandle(weak_factory_.GetWeakPtr()),
+      base::Bind(browser_sync::ChromeReportUnrecoverableError,
+                 chrome::GetChannel()),
+      get_http_post_provider_factory, saved_nigori_state_.Pass());
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
   DCHECK(encrypted_types.Has(syncer::PASSWORDS));
   return !Intersection(preferred_types, encrypted_types).Empty();
 }
@@ skipping 2177 matching lines @@
 }
 
 std::string ProfileSyncService::unrecoverable_error_message() const {
   return unrecoverable_error_message_;
 }
 
 tracked_objects::Location ProfileSyncService::unrecoverable_error_location()
     const {
   return unrecoverable_error_location_;
 }