[Sync] SyncEngine refactor part 1: interfaces.

components/sync/driver/glue/sync_backend_host_impl.h

 // Copyright 2013 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 COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 #define COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread.h"
+#include "base/threading/thread_checker.h"
 #include "components/invalidation/public/invalidation_handler.h"
 #include "components/sync/base/extensions_activity.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/weak_handle.h"
-#include "components/sync/driver/backend_data_type_configurer.h"
-#include "components/sync/driver/glue/sync_backend_host.h"
 #include "components/sync/engine/configure_reason.h"
 #include "components/sync/engine/cycle/sync_cycle_snapshot.h"
 #include "components/sync/engine/cycle/type_debug_info_observer.h"
+#include "components/sync/engine/model_type_configurer.h"
+#include "components/sync/engine/sync_engine.h"
 #include "components/sync/engine/sync_manager.h"
 #include "components/sync/protocol/encryption.pb.h"
 #include "components/sync/protocol/sync_protocol_error.h"
 
 class GURL;
 
 namespace invalidation {
 class InvalidationService;
 }  // namespace invalidation
 
 namespace syncer {
 
 class ChangeProcessor;
 class SyncBackendHostCore;
 class SyncBackendRegistrar;
 class SyncClient;
 class SyncManagerFactory;
 class SyncPrefs;
 class UnrecoverableErrorHandler;
 struct DoInitializeOptions;
 
-// The only real implementation of the SyncBackendHost.  See that interface's
+// The only real implementation of the SyncEngine. See that interface's
 // definition for documentation of public methods.
-class SyncBackendHostImpl : public SyncBackendHost, public InvalidationHandler {
+class SyncBackendHostImpl : public SyncEngine, public InvalidationHandler {
  public:
   typedef SyncStatus Status;
 
-  // Create a SyncBackendHost with a reference to the |frontend| that
-  // it serves and communicates to via the SyncFrontend interface (on
-  // the same thread it used to call the constructor).  Must outlive
-  // |sync_prefs|.
   SyncBackendHostImpl(
       const std::string& name,
       SyncClient* sync_client,
       invalidation::InvalidationService* invalidator,
       const base::WeakPtr<SyncPrefs>& sync_prefs,
       const base::FilePath& sync_folder);
   ~SyncBackendHostImpl() override;
 
-  // SyncBackendHost implementation.
+  // SyncEngine implementation.
   void Initialize(
-      SyncFrontend* frontend,
+      SyncEngineHost* host,
       scoped_refptr<base::SingleThreadTaskRunner> sync_task_runner,
       const WeakHandle<JsEventHandler>& event_handler,
       const GURL& service_url,
       const std::string& sync_user_agent,
       const SyncCredentials& credentials,
       bool delete_sync_data_folder,
       bool enable_local_sync_backend,
       const base::FilePath& local_sync_backend_folder,
       std::unique_ptr<SyncManagerFactory> sync_manager_factory,
       const WeakHandle<UnrecoverableErrorHandler>& unrecoverable_error_handler,
@@ skipping 80 matching lines @@
   // manager initialization to be passed back to the UI thread.
   //
   // |model_type_connector| is our ModelTypeConnector, which is owned because in
   // production it is a proxy object to the real ModelTypeConnector.
   virtual void HandleInitializationSuccessOnFrontendLoop(
       const WeakHandle<JsBackend> js_backend,
       const WeakHandle<DataTypeDebugInfoListener> debug_info_listener,
       std::unique_ptr<ModelTypeConnector> model_type_connector,
       const std::string& cache_guid);
 
-  // Forwards a ProtocolEvent to the frontend.  Will not be called unless a
-  // call to SetForwardProtocolEvents() explicitly requested that we start
-  // forwarding these events.
+  // Forwards a ProtocolEvent to the host. Will not be called unless a call to
+  // SetForwardProtocolEvents() explicitly requested that we start forwarding
+  // these events.
   void HandleProtocolEventOnFrontendLoop(std::unique_ptr<ProtocolEvent> event);
 
   // Forwards a directory commit counter update to the frontend loop.  Will not
   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
   // explicitly requested that we start forwarding these events.
   void HandleDirectoryCommitCountersUpdatedOnFrontendLoop(
       ModelType type,
       const CommitCounters& counters);
 
   // Forwards a directory update counter update to the frontend loop.  Will not
   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
   // explicitly requested that we start forwarding these events.
   void HandleDirectoryUpdateCountersUpdatedOnFrontendLoop(
       ModelType type,
       const UpdateCounters& counters);
 
   // Forwards a directory status counter update to the frontend loop.  Will not
   // be called unless a call to EnableDirectoryTypeDebugInfoForwarding()
   // explicitly requested that we start forwarding these events.
   void HandleDirectoryStatusCountersUpdatedOnFrontendLoop(
       ModelType type,
       const StatusCounters& counters);
 
   // Overwrites the kSyncInvalidationVersions preference with the most recent
   // set of invalidation versions for each type.
   void UpdateInvalidationVersions(
       const std::map<ModelType, int64_t>& invalidation_versions);
 
-  SyncFrontend* frontend() { return frontend_; }
+  SyncEngineHost* host() { return host_; }
 
  private:
   friend class SyncBackendHostCore;
 
   // 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();
 
   // Handles backend initialization failure.
@@ skipping 82 matching lines @@
 
   // Our core, which communicates directly to the syncapi. Use refptr instead
   // of WeakHandle because |core_| is created on UI loop but released on
   // sync loop.
   scoped_refptr<SyncBackendHostCore> core_;
 
   // A handle referencing the main interface for non-blocking sync types. This
   // object is owned because in production code it is a proxy object.
   std::unique_ptr<ModelTypeConnector> model_type_connector_;
 
-  bool initialized_;
+  bool initialized_ = false;
 
   const base::WeakPtr<SyncPrefs> sync_prefs_;
 
   std::unique_ptr<SyncBackendRegistrar> registrar_;
 
-  // The frontend which we serve (and are owned by).
-  SyncFrontend* frontend_;
+  // The host which we serve (and are owned by). Set in Initialize() and nulled
+  // out in StopSyncingForShutdown().
+  SyncEngineHost* host_ = nullptr;
 
   // We cache the cryptographer's pending keys whenever NotifyPassphraseRequired
   // is called. This way, before the UI calls SetDecryptionPassphrase on the
   // syncer, it can avoid the overhead of an asynchronous decryption call and
   // give the user immediate feedback about the passphrase entered by first
   // trying to decrypt the cached pending keys on the UI thread. Note that
   // SetDecryptionPassphrase can still fail after the cached pending keys are
   // successfully decrypted if the pending keys have changed since the time they
   // were cached.
   sync_pb::EncryptedData cached_pending_keys_;
 
   // The state of the passphrase required to decrypt the bag of encryption keys
   // in the nigori node. Updated whenever a new nigori node arrives or the user
   // manually changes their passphrase state. Cached so we can synchronously
   // check it from the UI thread.
-  PassphraseType cached_passphrase_type_;
+  PassphraseType cached_passphrase_type_ = PassphraseType::IMPLICIT_PASSPHRASE;
 
   // If an explicit passphrase is in use, the time at which the passphrase was
   // first set (if available).
   base::Time cached_explicit_passphrase_time_;
 
   // UI-thread cache of the last SyncCycleSnapshot received from syncapi.
   SyncCycleSnapshot last_snapshot_;
 
   invalidation::InvalidationService* invalidator_;
-  bool invalidation_handler_registered_;
+  bool invalidation_handler_registered_ = false;
 
   // Checks that we're on the same thread this was constructed on (UI thread).
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<SyncBackendHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostImpl);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_