[Sync] Make SyncBackendHost::Core use a WeakHandle to its host

chrome/browser/sync/glue/sync_backend_host.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 213 matching lines @@
   // for creating transactions.
   sync_api::UserShare* GetUserShare() const;
 
   // Called from any thread to obtain current status information in detailed or
   // summarized form.
   Status GetDetailedStatus();
   StatusSummary GetStatusSummary();
   const GoogleServiceAuthError& GetAuthError() const;
   const sessions::SyncSessionSnapshot* GetLastSessionSnapshot() const;
 
-  const FilePath& sync_data_folder_path() const {
-    return sync_data_folder_path_;
-  }
-
   // Determines if the underlying sync engine has made any local changes to
   // items that have not yet been synced with the server.
   // ONLY CALL THIS IF OnInitializationComplete was called!
   bool HasUnsyncedItems() const;
 
   // Whether or not we are syncing encryption keys.
   bool IsNigoriEnabled() const;
 
   // Whether or not the Nigori node is encrypted using an explicit passphrase.
   bool IsUsingExplicitPassphrase();
 
   // True if the cryptographer has any keys available to attempt decryption.
   // Could mean we've downloaded and loaded Nigori objects, or we bootstrapped
   // using a token previously received.
   bool IsCryptographerReady(const sync_api::BaseTransaction* trans) const;
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) const;
 
  protected:
+  // The types and functions below are protected so that test
+  // subclasses can use them.
+  //
+  // TODO(akalin): Figure out a better way for tests to hook into
+  // SyncBackendHost.
+
+  typedef base::Callback<sync_api::HttpPostProviderFactory*(void)>
+      MakeHttpBridgeFactoryFn;
+
+  struct DoInitializeOptions {
+    DoInitializeOptions(
+        MessageLoop* sync_loop,
+        SyncBackendRegistrar* registrar,
+        const WeakHandle<JsEventHandler>& event_handler,
+        const GURL& service_url,
+        MakeHttpBridgeFactoryFn make_http_bridge_factory_fn,
+        const sync_api::SyncCredentials& credentials,
+        sync_notifier::SyncNotifierFactory* sync_notifier_factory,
+        bool delete_sync_data_folder,
+        const std::string& restored_key_for_bootstrapping,
+        bool setup_for_test_mode);
+    ~DoInitializeOptions();
+
+    MessageLoop* sync_loop;
+    SyncBackendRegistrar* registrar;
+    WeakHandle<JsEventHandler> event_handler;
+    GURL service_url;
+    // Overridden by tests.
+    MakeHttpBridgeFactoryFn make_http_bridge_factory_fn;
+    sync_api::SyncCredentials credentials;
+    sync_notifier::SyncNotifierFactory* const sync_notifier_factory;
+    std::string lsid;
+    bool delete_sync_data_folder;
+    std::string restored_key_for_bootstrapping;
+    bool setup_for_test_mode;
+  };
+
+  // Allows tests to perform alternate core initialization work.
+  virtual void InitCore(const DoInitializeOptions& options);
+
+  // Called from Core::OnSyncCycleCompleted to handle updating frontend
+  // thread components.
+  void HandleSyncCycleCompletedOnFrontendLoop(
+      sessions::SyncSessionSnapshot* snapshot);
+
+  // Called to finish the job of ConfigureDataTypes once the syncer is in
+  // configuration mode.
+  void FinishConfigureDataTypesOnFrontendLoop();
+
+  bool IsDownloadingNigoriForTest() const;
+
+ private:
   // An enum representing the steps to initializing the SyncBackendHost.
   enum InitializationState {
     NOT_ATTEMPTED,
     CREATING_SYNC_MANAGER,  // We're waiting for the first callback from the
                             // sync thread to inform us that the sync manager
                             // has been created.
     NOT_INITIALIZED,        // Initialization hasn't completed, but we've
                             // constructed a SyncManager.
     DOWNLOADING_NIGORI,     // The SyncManager is initialized, but
                             // we're fetching encryption information.
     REFRESHING_ENCRYPTION,  // The SyncManager is initialized, and we
                             // have the encryption information, but we
                             // still need to refresh encryption.
     INITIALIZED,            // Initialization is complete.
   };
 
   // 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:
-    Core(const std::string& name, SyncBackendHost* backend);
+    Core(const std::string& name,
+         const FilePath& sync_data_folder_path,
+         const base::WeakPtr<SyncBackendHost>& backend);
 
     // SyncManager::Observer implementation.  The Core just acts like an air
     // traffic controller here, forwarding incoming messages to appropriate
     // landing threads.
     virtual void OnSyncCycleCompleted(
         const sessions::SyncSessionSnapshot* snapshot) OVERRIDE;
     virtual void OnInitializationComplete(
         const WeakHandle<JsBackend>& js_backend,
         bool success) OVERRIDE;
     virtual void OnAuthError(
         const GoogleServiceAuthError& auth_error) OVERRIDE;
     virtual void OnPassphraseRequired(
         sync_api::PassphraseRequiredReason reason) OVERRIDE;
     virtual void OnPassphraseAccepted(
         const std::string& bootstrap_token) OVERRIDE;
     virtual void OnStopSyncingPermanently() OVERRIDE;
     virtual void OnUpdatedToken(const std::string& token) OVERRIDE;
     virtual void OnClearServerDataFailed() OVERRIDE;
     virtual void OnClearServerDataSucceeded() OVERRIDE;
     virtual void OnEncryptedTypesChanged(
         syncable::ModelTypeSet encrypted_types,
         bool encrypt_everything) OVERRIDE;
     virtual void OnEncryptionComplete() OVERRIDE;
     virtual void OnActionableError(
         const browser_sync::SyncProtocolError& sync_error) OVERRIDE;
 
-    struct DoInitializeOptions {
-      DoInitializeOptions(
-          MessageLoop* sync_loop,
-          SyncBackendRegistrar* registrar,
-          const WeakHandle<JsEventHandler>& event_handler,
-          const GURL& service_url,
-          const scoped_refptr<net::URLRequestContextGetter>&
-              request_context_getter,
-          const sync_api::SyncCredentials& credentials,
-          bool delete_sync_data_folder,
-          const std::string& restored_key_for_bootstrapping,
-          bool setup_for_test_mode);
-      ~DoInitializeOptions();
-
-      MessageLoop* sync_loop;
-      SyncBackendRegistrar* registrar;
-      WeakHandle<JsEventHandler> event_handler;
-      GURL service_url;
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter;
-      sync_api::SyncCredentials credentials;
-      std::string lsid;
-      bool delete_sync_data_folder;
-      std::string restored_key_for_bootstrapping;
-      bool setup_for_test_mode;
-    };
-
     // Note:
     //
     // The Do* methods are the various entry points from our
     // SyncBackendHost.  They are all called on the sync thread to
     // actually perform synchronous (and potentially blocking) syncapi
     // operations.
     //
     // Called to perform initialization of the syncapi on behalf of
     // SyncBackendHost::Initialize.
     void DoInitialize(const DoInitializeOptions& options);
@@ skipping 60 matching lines @@
     sync_api::SyncManager* sync_manager() { return sync_manager_.get(); }
 
     // Delete the sync data folder to cleanup backend data.  Happens the first
     // time sync is enabled for a user (to prevent accidentally reusing old
     // sync databases), as well as shutdown when you're no longer syncing.
     void DeleteSyncDataFolder();
 
     // A callback from the SyncerThread when it is safe to continue config.
     void FinishConfigureDataTypes();
 
-    // Called to handle updating frontend thread components whenever we may
-    // need to alert the frontend that the backend is intialized.
-    void HandleInitializationCompletedOnFrontendLoop(
-        const WeakHandle<JsBackend>& js_backend,
-        bool success);
-
-    // Called when configuration of the Nigori node has completed as
-    // part of the initialization process.
-    void HandleNigoriConfigurationCompletedOnFrontendLoop(
-        const WeakHandle<JsBackend>& js_backend,
-        syncable::ModelTypeSet failed_configuration_types);
-
    private:
     friend class base::RefCountedThreadSafe<SyncBackendHost::Core>;
     friend class SyncBackendHostForProfileSyncTest;
 
     virtual ~Core();
 
     // Invoked when initialization of syncapi is complete and we can start
     // our timer.
     // This must be called from the thread on which SaveChanges is intended to
     // be run on; the host's |sync_thread_|.
     void StartSavingChanges();
 
     // Invoked periodically to tell the syncapi to persist its state
     // by writing to disk.
     // This is called from the thread we were created on (which is the
     // SyncBackendHost |sync_thread_|), using a repeating timer that is kicked
     // off as soon as the SyncManager tells us it completed
     // initialization.
     void SaveChanges();
 
-    // Let the front end handle the actionable error event.
-    void HandleActionableErrorEventOnFrontendLoop(
-        const browser_sync::SyncProtocolError& sync_error);
-
-    // Dispatched to from OnAuthError to handle updating frontend UI
-    // components.
-    void HandleAuthErrorEventOnFrontendLoop(
-        const GoogleServiceAuthError& new_auth_error);
-
-    // Invoked when a passphrase is required to decrypt a set of Nigori keys,
-    // or for encrypting. |reason| denotes why the passhrase was required.
-    void NotifyPassphraseRequired(sync_api::PassphraseRequiredReason reason);
-
-    // Invoked when the passphrase provided by the user has been accepted.
-    void NotifyPassphraseAccepted(const std::string& bootstrap_token);
-
-    // Invoked when an updated token is available from the sync server.
-    void NotifyUpdatedToken(const std::string& token);
-
-    // Invoked when the set of encrypted types or the encrypt
-    // everything flag changes.
-    void NotifyEncryptedTypesChanged(
-        syncable::ModelTypeSet encrypted_types,
-        bool encrypt_everything);
-
-    // Invoked when sync finishes encrypting new datatypes.
-    void NotifyEncryptionComplete();
-
-    // Called from Core::OnSyncCycleCompleted to handle updating frontend
-    // thread components.
-    void HandleSyncCycleCompletedOnFrontendLoop(
-        sessions::SyncSessionSnapshot* snapshot);
-
-    void HandleStopSyncingPermanentlyOnFrontendLoop();
-
-    // Called to handle success/failure of clearing server data
-    void HandleClearServerDataSucceededOnFrontendLoop();
-    void HandleClearServerDataFailedOnFrontendLoop();
-
-    void FinishConfigureDataTypesOnFrontendLoop();
-
     // Name used for debugging.
     const std::string name_;
 
-    // Our parent SyncBackendHost
-    SyncBackendHost* host_;
+    // Path of the folder that stores the sync data files.
+    const FilePath sync_data_folder_path_;
+
+    // Our parent SyncBackendHost.
+    WeakHandle<SyncBackendHost> host_;
 
     // The loop where all the sync backend operations happen.
     // Non-NULL only between calls to DoInitialize() and DoShutdown().
     MessageLoop* sync_loop_;
 
     // Our parent's registrar (not owned).  Non-NULL only between
     // calls to DoInitialize() and DoShutdown().
     SyncBackendRegistrar* registrar_;
 
     // The timer used to periodically call SaveChanges.
     base::RepeatingTimer<Core> save_changes_timer_;
 
     // The top-level syncapi entry point.  Lives on the sync thread.
     scoped_ptr<sync_api::SyncManager> sync_manager_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
+  struct PendingConfigureDataTypesState {
+    PendingConfigureDataTypesState();
+    ~PendingConfigureDataTypesState();
+
+    // The ready_task will be run when configuration is done with the
+    // set of all types that failed configuration (i.e., if its
+    // argument is non-empty, then an error was encountered).
+    base::Callback<void(syncable::ModelTypeSet)> ready_task;
+
+    // The set of types that we are waiting to be initially synced in a
+    // configuration cycle.
+    syncable::ModelTypeSet types_to_add;
+
+    // Additional details about which types were added.
+    syncable::ModelTypeSet added_types;
+    sync_api::ConfigureReason reason;
+  };
+
   // Checks if we have received a notice to turn on experimental datatypes
   // (via the nigori node) and informs the frontend if that is the case.
   // Note: it is illegal to call this before the backend is initialized.
   void AddExperimentalTypes();
 
   // InitializationComplete passes through the SyncBackendHost to forward
   // on to |frontend_|, and so that tests can intercept here if they need to
   // set up initial conditions.
   virtual void HandleInitializationCompletedOnFrontendLoop(
       const WeakHandle<JsBackend>& js_backend,
       bool success);
 
-  // Called to finish the job of ConfigureDataTypes once the syncer is in
-  // configuration mode.
-  void FinishConfigureDataTypesOnFrontendLoop();
-
-  // Allows tests to perform alternate core initialization work.
-  virtual void InitCore(const Core::DoInitializeOptions& options);
-
-  // Factory method for HttpPostProviderFactories.  Should be
-  // thread-safe.
-  virtual sync_api::HttpPostProviderFactory* MakeHttpBridgeFactory(
-      const scoped_refptr<net::URLRequestContextGetter>& getter);
-
   // Helpers to persist a token that can be used to bootstrap sync encryption
   // across browser restart to avoid requiring the user to re-enter their
   // passphrase.  |token| must be valid UTF-8 as we use the PrefService for
   // storage.
   void PersistEncryptionBootstrapToken(const std::string& token);
 
-  // Our core, which communicates directly to the syncapi.
-  scoped_refptr<Core> core_;
-
-  InitializationState initialization_state_;
-
- private:
-  struct PendingConfigureDataTypesState {
-    PendingConfigureDataTypesState();
-    ~PendingConfigureDataTypesState();
-
-    // The ready_task will be run when configuration is done with the
-    // set of all types that failed configuration (i.e., if its
-    // argument is non-empty, then an error was encountered).
-    base::Callback<void(syncable::ModelTypeSet)> ready_task;
-
-    // The set of types that we are waiting to be initially synced in a
-    // configuration cycle.
-    syncable::ModelTypeSet types_to_add;
-
-    // Additional details about which types were added.
-    syncable::ModelTypeSet added_types;
-    sync_api::ConfigureReason reason;
-  };
-
   // For convenience, checks if initialization state is INITIALIZED.
   bool initialized() const { return initialization_state_ == INITIALIZED; }
 
+  // Let the front end handle the actionable error event.
+  void HandleActionableErrorEventOnFrontendLoop(
+      const browser_sync::SyncProtocolError& sync_error);
+
+  // Invoked when a passphrase is required to decrypt a set of Nigori keys,
+  // or for encrypting. |reason| denotes why the passhrase was required.
+  void NotifyPassphraseRequired(sync_api::PassphraseRequiredReason reason);
+
+  // Invoked when the passphrase provided by the user has been accepted.
+  void NotifyPassphraseAccepted(const std::string& bootstrap_token);
+
+  // Invoked when an updated token is available from the sync server.
+  void NotifyUpdatedToken(const std::string& token);
+
+  // Invoked when the set of encrypted types or the encrypt
+  // everything flag changes.
+  void NotifyEncryptedTypesChanged(
+      syncable::ModelTypeSet encrypted_types,
+      bool encrypt_everything);
+
+  // Invoked when sync finishes encrypting new datatypes.
+  void NotifyEncryptionComplete();
+
+  void HandleStopSyncingPermanentlyOnFrontendLoop();
+
+  // Called to handle success/failure of clearing server data
+  void HandleClearServerDataSucceededOnFrontendLoop();
+  void HandleClearServerDataFailedOnFrontendLoop();
+
+  // Dispatched to from OnAuthError to handle updating frontend UI
+  // components.
+  void HandleAuthErrorEventOnFrontendLoop(
+      const GoogleServiceAuthError& new_auth_error);
+
+  // Called when configuration of the Nigori node has completed as
+  // part of the initialization process.
+  void HandleNigoriConfigurationCompletedOnFrontendLoop(
+      const WeakHandle<JsBackend>& js_backend,
+      syncable::ModelTypeSet failed_configuration_types);
+
   // Must be called on |frontend_loop_|.  |done_callback| is called on
   // |frontend_loop_|.
   void RefreshEncryption(const base::Closure& done_callback);
 
   // Handles stopping the core's SyncManager, accounting for whether
   // initialization is done yet.
   void StopSyncManagerForShutdown(const base::Closure& closure);
 
+  base::WeakPtrFactory<SyncBackendHost> weak_ptr_factory_;
+
   // A thread where all the sync operations happen.
   base::Thread sync_thread_;
 
   // A reference to the MessageLoop used to construct |this|, so we know how
   // to safely talk back to the SyncFrontend.
   MessageLoop* const frontend_loop_;
 
   Profile* const profile_;
 
-  const base::WeakPtr<SyncPrefs> sync_prefs_;
-
   // Name used for debugging (set from profile_->GetDebugName()).
   const std::string name_;
 
+  // Our core, which communicates directly to the syncapi.
+  scoped_refptr<Core> core_;
+
+  InitializationState initialization_state_;
+
+  const base::WeakPtr<SyncPrefs> sync_prefs_;
+
   sync_notifier::SyncNotifierFactory sync_notifier_factory_;
 
   scoped_ptr<SyncBackendRegistrar> registrar_;
 
   // The frontend which we serve (and are owned by).
   SyncFrontend* frontend_;
 
-  // Path of the folder that stores the sync data files.
-  FilePath sync_data_folder_path_;
-
   scoped_ptr<PendingConfigureDataTypesState> pending_download_state_;
   scoped_ptr<PendingConfigureDataTypesState> pending_config_mode_state_;
 
   // UI-thread cache of the last AuthErrorState received from syncapi.
   GoogleServiceAuthError last_auth_error_;
 
   // UI-thread cache of the last SyncSessionSnapshot received from syncapi.
   scoped_ptr<sessions::SyncSessionSnapshot> last_snapshot_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_