Fix ProfileSyncService unit test.

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2006-2008 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.
 
 #if defined(BROWSER_SYNC)
 
 #include "build/build_config.h"
 #include "base/file_version_info.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
@@ skipping 27 matching lines @@
 
 SyncBackendHost::~SyncBackendHost() {
   DCHECK(!core_ && !frontend_) << "Must call Shutdown before destructor.";
 }
 
 void SyncBackendHost::Initialize(const GURL& sync_service_url,
                                  URLRequestContext* baseline_context) {
   if (!core_thread_.Start())
     return;
   bookmark_model_worker_ = new BookmarkModelWorker(frontend_loop_);
-  core_.get()->SetBaseRequestContext(baseline_context);
+
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoInitialize,
-                        sync_service_url, bookmark_model_worker_, true));
+                        sync_service_url, bookmark_model_worker_, true,
+                        new HttpBridgeFactory(baseline_context),
+                        new HttpBridgeFactory(baseline_context)));
 }
 
 void SyncBackendHost::Authenticate(const std::string& username,
                                    const std::string& password) {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoAuthenticate,
                         username, password));
 }
 
 void SyncBackendHost::Shutdown(bool sync_disabled) {
@@ skipping 58 matching lines @@
 }
 
 string16 SyncBackendHost::GetAuthenticatedUsername() const {
   return UTF8ToUTF16(core_->syncapi()->GetAuthenticatedUsername());
 }
 
 AuthErrorState SyncBackendHost::GetAuthErrorState() const {
   return last_auth_error_;
 }
 
-void SyncBackendHost::Core::SetBaseRequestContext(
-    URLRequestContext* request_context) {
-  DCHECK(base_request_context_ == NULL);
-  base_request_context_ = request_context;
-  // This ref is removed on the IO thread after the core thread is over.
-  base_request_context_->AddRef();
-}
-
 SyncBackendHost::Core::Core(SyncBackendHost* backend)
     : host_(backend),
-      base_request_context_(NULL),
       syncapi_(new sync_api::SyncManager()) {
 }
 
-SyncBackendHost::Core::~Core() {
-  if (base_request_context_) {
-    ChromeThread::GetMessageLoop(ChromeThread::IO)->ReleaseSoon(FROM_HERE,
-        base_request_context_);
-    base_request_context_ = NULL;
-  }
-}
-
 // Helper to construct a user agent string (ASCII) suitable for use by
 // the syncapi for any HTTP communication. This string is used by the sync
 // backend for classifying client types when calculating statistics.
 std::string MakeUserAgentForSyncapi() {
   std::string user_agent;
   user_agent = "Chrome ";
 #if defined(OS_WIN)
   user_agent += "WIN ";
 #elif defined(OS_LINUX)
   user_agent += "LINUX ";
@@ skipping 10 matching lines @@
   user_agent += WideToASCII(version_info->product_version());
   user_agent += " (" + WideToASCII(version_info->last_change()) + ")";
   if (!version_info->is_official_build())
     user_agent += "-devel";
   return user_agent;
 }
 
 void SyncBackendHost::Core::DoInitialize(
     const GURL& service_url,
     BookmarkModelWorker* bookmark_model_worker,
-    bool attempt_last_user_authentication) {
+    bool attempt_last_user_authentication,
+    sync_api::HttpPostProviderFactory* http_provider_factory,
+    sync_api::HttpPostProviderFactory* auth_http_provider_factory) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
 
   // Make sure that the directory exists before initializing the backend.
   // If it already exists, this will do no harm.
   bool success = file_util::CreateDirectory(host_->sync_data_folder_path());
   DCHECK(success);
 
   syncapi_->SetObserver(this);
   string16 path_str;
 #if defined (OS_WIN)
   path_str = host_->sync_data_folder_path().value();
 #elif defined(OS_LINUX) || defined(OS_MACOSX)
   path_str = UTF8ToUTF16(host_->sync_data_folder_path().value());
 #endif
   success = syncapi_->Init(path_str.c_str(),
       (service_url.host() + service_url.path()).c_str(),
       service_url.EffectiveIntPort(),
       kGaiaServiceId,
       kGaiaSourceForChrome,
       service_url.SchemeIsSecure(),
-      new HttpBridgeFactory(base_request_context_),
-      new HttpBridgeFactory(base_request_context_),
+      http_provider_factory,
+      auth_http_provider_factory,
       bookmark_model_worker,
       attempt_last_user_authentication,
       MakeUserAgentForSyncapi().c_str());
   DCHECK(success) << "Syncapi initialization failed!";
 }
 
 void SyncBackendHost::Core::DoAuthenticate(const std::string& username,
                                            const std::string& password) {
   DCHECK(MessageLoop::current() == host_->core_thread_.message_loop());
   syncapi_->Authenticate(username.c_str(), password.c_str());
@@ skipping 105 matching lines @@
       this, &Core::SaveChanges);
 }
 
 void SyncBackendHost::Core::SaveChanges() {
   syncapi_->SaveChanges();
 }
 
 }  // namespace browser_sync
 
 #endif  // defined(BROWSER_SYNC)