[Sync] Move change-related methods out of SyncManager::Observer

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 206 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;
 
   // 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;
 
-  // Logs the unsynced items.
-  void LogUnsyncedItems(int level) 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:
   // An enum representing the steps to initializing the SyncBackendHost.
   enum InitializationState {
-    NOT_INITIALIZED,     // Initialization hasn't completed.
-    DOWNLOADING_NIGORI,  // The SyncManager is initialized, but we're fetching
-                         // encryption information before alerting the
-                         // frontend.
-    INITIALIZED,         // Initialization is complete.
+    NOT_INITIALIZED,        // Initialization hasn't completed.
+    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);
 
     // SyncManager::Observer implementation.  The Core just acts like an air
     // traffic controller here, forwarding incoming messages to appropriate
     // landing threads.
-    virtual void OnChangesApplied(
-        syncable::ModelType model_type,
-        const sync_api::BaseTransaction* trans,
-        const sync_api::ImmutableChangeRecordList& changes) OVERRIDE;
-    virtual void OnChangesComplete(
-        syncable::ModelType model_type) OVERRIDE;
     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 OnEncryptionComplete(
         const syncable::ModelTypeSet& encrypted_types);
     virtual void OnActionableError(
         const browser_sync::SyncProtocolError& sync_error);
 
     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.
-    // It calls us on a dedicated thread to actually perform synchronous
-    // (and potentially blocking) syncapi operations.
+    // 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 on the SyncBackendHost sync_thread_ to perform initialization
-    // of the syncapi on behalf of SyncBackendHost::Initialize.
+    // Called to perform initialization of the syncapi on behalf of
+    // SyncBackendHost::Initialize.
     void DoInitialize(const DoInitializeOptions& options);
 
-    // Called on our SyncBackendHost's sync_thread_ to perform credential
-    // update on behalf of SyncBackendHost::UpdateCredentials
+    // Called to perform credential update on behalf of
+    // SyncBackendHost::UpdateCredentials
     void DoUpdateCredentials(const sync_api::SyncCredentials& credentials);
 
     // Called when the user disables or enables a sync type.
     void DoUpdateEnabledTypes();
 
-    // Called on the SyncBackendHost sync_thread_ to tell the syncapi to start
-    // syncing (generally after initialization and authentication).
+    // Called to tell the syncapi to start syncing (generally after
+    // initialization and authentication).
     void DoStartSyncing();
 
-    // Called on the SyncBackendHost sync_thread_ to clear server
-    // data.
+    // Called to clear server data.
     void DoRequestClearServerData();
 
-    // Called on the SyncBackendHost sync_thread_ to cleanup disabled
-    // types.
+    // Called to cleanup disabled types.
     void DoRequestCleanupDisabledTypes();
 
-    // Called on our SyncBackendHost's |sync_thread_| to set the passphrase
-    // on behalf of SyncBackendHost::SupplyPassphrase.
+    // Called to set the passphrase on behalf of
+    // SyncBackendHost::SupplyPassphrase.
     void DoSetPassphrase(const std::string& passphrase, bool is_explicit);
 
-    // Called on SyncBackendHost's |sync_thread_| to turn on encryption of all
-    // sync data as well as reencrypt everything.
+    // Called to turn on encryption of all sync data as well as
+    // reencrypt everything.
     void DoEnableEncryptEverything();
 
+    // Called to refresh encryption with the most recent passphrase
+    // and set of encrypted types.  |done_callback| is called on the
+    // sync thread.
+    void DoRefreshEncryption(const base::Closure& done_callback);
+
     // The shutdown order is a bit complicated:
     // 1) From |sync_thread_|, invoke the syncapi Shutdown call to do
     //    a final SaveChanges, and close sqlite handles.
     // 2) Then, from |frontend_loop_|, halt the sync_thread_ (which is
     //    a blocking call). 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);
 
-    // Posts a config request on the sync thread.
     virtual void DoRequestConfig(
         const syncable::ModelTypeBitSet& types_to_config,
         sync_api::ConfigureReason reason);
 
-    // Start the configuration mode.
+    // Start the configuration mode.  |callback| is called on the sync
+    // thread.
     virtual void DoStartConfiguration(Callback0::Type* callback);
 
     // 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.
 
     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
@@ skipping 65 matching lines @@
     void HandleClearServerDataFailedOnFrontendLoop();
 
     void FinishConfigureDataTypesOnFrontendLoop();
 
     // Name used for debugging.
     const std::string name_;
 
     // Our parent SyncBackendHost
     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_;
 
@@ skipping 12 matching lines @@
   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);
 
-  MessageLoop* sync_loop() { return sync_thread_.message_loop(); }
-
   // 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);
   std::string RestoreEncryptionBootstrapToken();
 
   // Our core, which communicates directly to the syncapi.
   scoped_refptr<Core> core_;
 
@@ skipping 13 matching lines @@
     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; }
 
+  // Must be called on |frontend_loop_|.  |done_callback| is called on
+  // |frontend_loop_|.
+  void RefreshEncryption(const base::Closure& done_callback);
+
   // 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_;
 
   // Name used for debugging (set from profile_->GetDebugName()).
@@ skipping 17 matching lines @@
 
   // 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_