[Sync] Split DirectoryChangeListener for thread-safety

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 380 matching lines @@
     virtual void DoRequestConfig(const syncable::ModelTypeBitSet& added_types,
         sync_api::ConfigureReason reason);
 
     // Start the configuration mode.
     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* syncapi() { return syncapi_.get(); }
+    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();
 
     void ConnectChildJsEventRouter();
 
     void DisconnectChildJsEventRouter();
 
@@ skipping 70 matching lines @@
         sessions::SyncSessionSnapshot* snapshot);
 
     void HandleStopSyncingPermanentlyOnFrontendLoop();
 
     // Called to handle success/failure of clearing server data
     void HandleClearServerDataSucceededOnFrontendLoop();
     void HandleClearServerDataFailedOnFrontendLoop();
 
     // Called from Core::OnInitializationComplete to handle updating
     // frontend thread components.
-    void HandleInitalizationCompletedOnFrontendLoop();
+    void HandleInitializationCompletedOnFrontendLoop();
 
     void RouteJsEventOnFrontendLoop(
         const std::string& name, const JsEventDetails& details);
 
     void RouteJsMessageReplyOnFrontendLoop(
         const std::string& name, const JsArgList& args,
         const JsEventHandler* target);
 
     void FinishConfigureDataTypesOnFrontendLoop();
 
     // Return true if a model lives on the current thread.
     bool IsCurrentThreadSafeForModel(syncable::ModelType model_type);
 
+    const std::string name_;

[tim (not reviewing), 2011/06/16 21:10:58]

what is |name_|? name of what?

[akalin, 2011/06/16 22:23:12]

Done.

+
     // Our parent SyncBackendHost
     SyncBackendHost* host_;
 
     // 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_;
+    // The top-level syncapi entry point.  Lives on the sync thread.
+    scoped_ptr<sync_api::SyncManager> sync_manager_;

[tim (not reviewing), 2011/06/16 21:10:58]

I prefer the old name :\ but if you really want to change it shouldn't we change
it everywhere lest we make things more confusing? one example - ui_model_worker
still refers to it as "syncapi"

[akalin, 2011/06/16 22:23:12]

Well, the problem with the name "syncapi" is that it's overloaded.  Here it was
used to mean "instance of the SyncManager class", in ui_model_worker, according
to the comments, it's really referring to the sync *thread*, and in other places
(DirectoryChangeDelegate) it's used to mean "from Chrome" as opposed to "from
the cloud".

I'll fix ui_model_worker et al. in a separate CL.

 
     scoped_ptr<sync_notifier::SyncNotifier> sync_notifier_;
 
     JsSyncManagerObserver sync_manager_observer_;
 
     JsEventRouter* parent_router_;
 
     // Denotes if the core is currently attempting to set a passphrase. While
     // this is true, OnPassphraseRequired calls are dropped.
     // Note: after initialization, this variable should only ever be accessed or
@@ skipping 22 matching lines @@
 
   // Allows tests to perform alternate core initialization work.
   virtual void InitCore(const Core::DoInitializeOptions& options);
 
   // Factory method for HttpPostProviderFactories.
   virtual sync_api::HttpPostProviderFactory* MakeHttpBridgeFactory(
       net::URLRequestContextGetter* getter);
 
   MessageLoop* sync_loop() { return sync_thread_.message_loop(); }
 
-  void set_syncapi_initialized() { syncapi_initialized_ = true; }
-
   // 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 79 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_;
 
   // Whether we've processed the initialization complete callback.
-  bool syncapi_initialized_;
+  bool sync_manager_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_