[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;
@@ skipping 12 matching lines @@
 
   // 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;
     };
@@ skipping 131 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 50 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_