make new syncer thread the default.

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 177 matching lines @@
   // be called synchronously with the data type's model association so
   // no changes are dropped between model association and change
   // processor activation.
   void ActivateDataType(DataTypeController* data_type_controller,
                         ChangeProcessor* change_processor);
 
   // Deactivates change processing for the given data type.
   void DeactivateDataType(DataTypeController* data_type_controller,
                           ChangeProcessor* change_processor);
 
-  // Requests the backend to pause.  Returns true if the request is
-  // sent sucessfully.  When the backend does pause, a SYNC_PAUSED
-  // notification is sent to the notification service.
-  virtual bool RequestPause();
-
-  // Requests the backend to resume.  Returns true if the request is
-  // sent sucessfully.  When the backend does resume, a SYNC_RESUMED
-  // notification is sent to the notification service.
-  virtual bool RequestResume();
-
   // Asks the server to clear all data associated with ChromeSync.
   virtual bool RequestClearServerData();
 
   // Called on |frontend_loop_| to obtain a handle to the UserShare needed
   // for creating transactions.
   sync_api::UserShare* GetUserShare() const;
 
   // Called from any thread to obtain current status information in detailed or
   // summarized form.
   Status GetDetailedStatus();
@@ skipping 57 matching lines @@
         const sync_api::SyncManager::ChangeRecord* changes,
         int change_count);
     virtual void OnChangesComplete(syncable::ModelType model_type);
     virtual void OnSyncCycleCompleted(
         const sessions::SyncSessionSnapshot* snapshot);
     virtual void OnInitializationComplete();
     virtual void OnAuthError(const GoogleServiceAuthError& auth_error);
     virtual void OnPassphraseRequired(bool for_decryption);
     virtual void OnPassphraseFailed();
     virtual void OnPassphraseAccepted(const std::string& bootstrap_token);
-    virtual void OnPaused();
-    virtual void OnResumed();
     virtual void OnStopSyncingPermanently();
     virtual void OnUpdatedToken(const std::string& token);
     virtual void OnClearServerDataFailed();
     virtual void OnClearServerDataSucceeded();
     virtual void OnEncryptionComplete(
         const syncable::ModelTypeSet& encrypted_types);
 
     // JsBackend implementation.
     virtual void SetParentJsEventRouter(JsEventRouter* router);
     virtual void RemoveParentJsEventRouter();
@@ skipping 46 matching lines @@
     // Called when the user disables or enables a sync type.
     void DoUpdateEnabledTypes();
 
     // Called on the SyncBackendHost core_thread_ to tell the syncapi to start
     // syncing (generally after initialization and authentication).
     void DoStartSyncing();
 
     // Called on the SyncBackendHost core_thread_ to nudge/pause/resume the
     // syncer.
     void DoRequestNudge(const tracked_objects::Location& location);
-    void DoRequestPause();
-    void DoRequestResume();
     void DoRequestClearServerData();
 
     // Sets |deferred_nudge_for_cleanup_requested_| to true. See comment below.
     void DeferNudgeForCleanup();
 
     // Called on our SyncBackendHost's |core_thread_| to set the passphrase
     // on behalf of SyncBackendHost::SupplyPassphrase.
     void DoSetPassphrase(const std::string& passphrase, bool is_explicit);
 
     // Getter/setter for whether we are waiting on SetPassphrase to process a
@@ skipping 10 matching lines @@
     // 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);
 
+    // Posts a config request on the core thread.
+    virtual void DoRequestConfig(const syncable::ModelTypeBitSet& added_types);
+
     // 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* syncapi() { return syncapi_.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();
 
     void ConnectChildJsEventRouter();
 
     void DisconnectChildJsEventRouter();
 
     void DoProcessMessage(
         const std::string& name, const JsArgList& args,
         const JsEventHandler* sender);
 
-    void DoStartConfigurationMode();
-
     // A callback from the SyncerThread when it is safe to continue config.
     void FinishConfigureDataTypes();
 
 #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 usable state.
     void DoInitializeForTest(const std::wstring& test_user,
                              sync_api::HttpPostProviderFactory* factory,
                              bool delete_sync_data_folder) {
       // Construct dummy credentials for test.
       sync_api::SyncCredentials credentials;
       credentials.email = WideToUTF8(test_user);
       credentials.sync_token = "token";
       DoInitialize(DoInitializeOptions(GURL(), factory, credentials,
                                        delete_sync_data_folder,
                                        "", true));
     }
 #endif
 
    private:
     friend class base::RefCountedThreadSafe<SyncBackendHost::Core>;
     friend class SyncBackendHostForProfileSyncTest;
 
     virtual ~Core();
 
     // Return change processor for a particular model (return NULL on failure).
     ChangeProcessor* GetProcessor(syncable::ModelType modeltype);
 
-
-    // Sends a SYNC_PAUSED notification to the notification service on
-    // the UI thread.
-    void NotifyPaused();
-
-    // Sends a SYNC_RESUMED notification to the notification service
-    // on the UI thread.
-    void NotifyResumed();
-
     // 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 |core_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 |core_thread_|), using a repeating timer that is kicked
@@ skipping 80 matching lines @@
   };
 
   // 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();
 
   // Posts a nudge request on the core thread.
   virtual void RequestNudge(const tracked_objects::Location& location);
 
-  // Posts a config request on the core thread.
-  virtual void RequestConfig(const syncable::ModelTypeBitSet& added_types);
-
   // Called to finish the job of ConfigureDataTypes once the syncer is in
   // configuration mode.
   void FinishConfigureDataTypes();
   void FinishConfigureDataTypesOnFrontendLoop();
 
   // Allows tests to perform alternate core initialization work.
   virtual void InitCore(const Core::DoInitializeOptions& options);
 
   // Factory method for HttpPostProviderFactories.
   virtual sync_api::HttpPostProviderFactory* MakeHttpBridgeFactory(
@@ skipping 93 matching lines @@
 
   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_;
 
-  // While two impls are in flight, using this for sanity checking. Bug 26339.
-  const bool using_new_syncer_thread_;
-
   // Whether we've processed the initialization complete callback.
   bool syncapi_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_