Fix ProfileSyncService unit test.

chrome/browser/sync/glue/sync_backend_host.h

 // 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)
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "base/timer.h"
 #include "chrome/browser/sync/auth_error_state.h"
 #include "chrome/browser/sync/engine/syncapi.h"
 #include "chrome/browser/sync/glue/bookmark_model_worker.h"
+
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request_context.h"
 
 namespace browser_sync {
 
 // SyncFrontend is the interface used by SyncBackendHost to communicate with
 // the entity that created it and, presumably, is interested in sync-related
 // activity.
 // NOTE: All methods will be invoked by a SyncBackendHost on the same thread
 // used to create that SyncBackendHost.
@@ skipping 79 matching lines @@
   }
 
   // Returns the authenticated username of the sync user, or empty if none
   // exists. It will only exist if the authentication service provider (e.g
   // GAIA) has confirmed the username is authentic.
   string16 GetAuthenticatedUsername() const;
 
 #if defined(UNIT_TEST)
   // Called from unit test to bypass authentication and initialize the syncapi
   // to a state suitable for testing but not production.
-  void InitializeForTestMode(const std::wstring& test_user) {
+  void InitializeForTestMode(const std::wstring& test_user,
+                             sync_api::HttpPostProviderFactory* factory,
+                             sync_api::HttpPostProviderFactory* auth_factory) {
     if (!core_thread_.Start())
       return;
     bookmark_model_worker_ = new BookmarkModelWorker(frontend_loop_);
+
     core_thread_.message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(core_.get(),
         &SyncBackendHost::Core::DoInitializeForTest,
         bookmark_model_worker_,
-        test_user));
+        test_user,
+        factory,
+        auth_factory));
   }
 #endif
 
  private:
   // The real guts of SyncBackendHost, to keep the public client API clean.
   class Core : public base::RefCountedThreadSafe<SyncBackendHost::Core>,
                public sync_api::SyncManager::Observer {
    public:
     explicit Core(SyncBackendHost* backend);
 
-    // Note: This destructor should *always* be called from the thread that
-    // created it, and *always* after core_thread_ has exited. The syncapi
-    // watches thread exit events and keeps pointers to objects this dtor will
-    // destroy, so this ordering is important.
-    ~Core();
-
     // SyncManager::Observer implementation.  The Core just acts like an air
     // traffic controller here, forwarding incoming messages to appropriate
     // landing threads.
     virtual void OnChangesApplied(
         const sync_api::BaseTransaction* trans,
         const sync_api::SyncManager::ChangeRecord* changes,
         int change_count);
     virtual void OnSyncCycleCompleted();
     virtual void OnInitializationComplete();
     virtual void OnAuthProblem(
         sync_api::SyncManager::AuthProblem auth_problem);
 
     // Note:
     //
     // The Do* methods are the various entry points from our SyncBackendHost.
     // It calls us on a dedicated thread to actually perform synchronous
     // (and potentially blocking) syncapi operations.
     //
     // Called on the SyncBackendHost core_thread_ to perform initialization
     // of the syncapi on behalf of SyncBackendHost::Initialize.
     void DoInitialize(const GURL& service_url,
-                      BookmarkModelWorker* bookmark_model_worker,
-                      bool attempt_last_user_authentication);
+        BookmarkModelWorker* bookmark_model_worker,
+        bool attempt_last_user_authentication,
+        sync_api::HttpPostProviderFactory* http_bridge_factory,
+        sync_api::HttpPostProviderFactory* auth_http_bridge_factory);
 
     // Called on our SyncBackendHost's core_thread_ to perform authentication
     // on behalf of SyncBackendHost::Authenticate.
     void DoAuthenticate(const std::string& username,
                         const std::string& password);
 
     // The shutdown order is a bit complicated:
     // 1) From |core_thread_|, invoke the syncapi Shutdown call to do a final
     //    SaveChanges, close sqlite handles, and halt the syncer thread (which
     //    could potentially block for 1 minute).
     // 2) Then, from |frontend_loop_|, halt the core_thread_. This causes
     //    syncapi thread-exit handlers to run and make use of cached pointers to
     //    various components owned implicitly by us.
     // 3) Destroy this Core. That will delete syncapi components in a safe order
     //    because the thread that was using them has exited (in step 2).
     void DoShutdown(bool stopping_sync);
 
     // Set the base request context to use when making HTTP calls.
     // This method will add a reference to the context to persist it
     // on the IO thread. Must be removed from IO thread.
-    // TODO(chron): After HttpNetworkSession reorganization happens, try
-    //              getting HttpBridgeFactory to initialize earlier.
-    void SetBaseRequestContext(URLRequestContext* request_context);
 
     sync_api::SyncManager* syncapi() { return syncapi_.get(); }
 
 #if defined(UNIT_TEST)
     // Special form of initialization that does not try and authenticate the
     // last known user (since it will fail in test mode) and does some extra
     // setup to nudge the syncapi into a useable state.
     void DoInitializeForTest(BookmarkModelWorker* bookmark_model_worker,
-                             const std::wstring& test_user) {
-        DoInitialize(GURL(), bookmark_model_worker, false);
+                             const std::wstring& test_user,
+                             sync_api::HttpPostProviderFactory* factory,
+                             sync_api::HttpPostProviderFactory* auth_factory) {
+        DoInitialize(GURL(), bookmark_model_worker, false, factory,
+                     auth_factory);
         syncapi_->SetupForTestMode(WideToUTF16(test_user).c_str());
     }
 #endif
 
    private:
     // FrontendNotification defines parameters for NotifyFrontend. Each enum
     // value corresponds to the one SyncFrontend interface method that
     // NotifyFrontend should invoke.
     enum FrontendNotification {
       INITIALIZED,                    // OnBackendInitialized.
@@ skipping 23 matching lines @@
     // initialization.
     void SaveChanges();
 
     // Dispatched to from HandleAuthErrorEventOnCoreLoop to handle updating
     // frontend UI components.
     void HandleAuthErrorEventOnFrontendLoop(AuthErrorState new_auth_error);
 
     // Our parent SyncBackendHost
     SyncBackendHost* host_;
 
-    // Our request context that we have to keep a ref to.
-    // Contains session data.
-    URLRequestContext* base_request_context_;
-
     // The timer used to periodically call SaveChanges.
     base::RepeatingTimer<Core> save_changes_timer_;
 
     // The top-level syncapi entry point.
     scoped_ptr<sync_api::SyncManager> syncapi_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   // A thread we dedicate for use by our Core to perform initialization,
@@ skipping 26 matching lines @@
   // UI-thread cache of the last AuthErrorState received from syncapi.
   AuthErrorState last_auth_error_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #endif  // defined(BROWSER_SYNC)