[Sync] Move //components/sync_driver to //components/sync/driver.

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 "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/core/configure_reason.h"
 #include "components/sync/core/sync_manager.h"
+#include "components/sync/driver/backend_data_type_configurer.h"
+#include "components/sync/driver/glue/sync_backend_host.h"
 #include "components/sync/protocol/encryption.pb.h"
 #include "components/sync/protocol/sync_protocol_error.h"
 #include "components/sync/sessions/sync_session_snapshot.h"
 #include "components/sync/sessions/type_debug_info_observer.h"
-#include "components/sync_driver/backend_data_type_configurer.h"
-#include "components/sync_driver/glue/sync_backend_host.h"
 
 class GURL;
 
 namespace base {
 class MessageLoop;
 }
 
 namespace invalidation {
 class InvalidationService;
 }
@@ skipping 10 matching lines @@
 
 namespace browser_sync {
 
 class ChangeProcessor;
 class SyncBackendHostCore;
 class SyncBackendRegistrar;
 struct DoInitializeOptions;
 
 // The only real implementation of the SyncBackendHost.  See that interface's
 // definition for documentation of public methods.
-class SyncBackendHostImpl
-    : public SyncBackendHost,
-      public syncer::InvalidationHandler {
+class SyncBackendHostImpl : public SyncBackendHost,
+                            public syncer::InvalidationHandler {
  public:
   typedef syncer::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,
       sync_driver::SyncClient* sync_client,
@@ skipping 90 matching lines @@
   // Request the syncer to reconfigure with the specfied params.
   // Virtual for testing.
   virtual void RequestConfigureSyncer(
       syncer::ConfigureReason reason,
       syncer::ModelTypeSet to_download,
       syncer::ModelTypeSet to_purge,
       syncer::ModelTypeSet to_journal,
       syncer::ModelTypeSet to_unapply,
       syncer::ModelTypeSet to_ignore,
       const syncer::ModelSafeRoutingInfo& routing_info,
-      const base::Callback<void(syncer::ModelTypeSet,
-                                syncer::ModelTypeSet)>& ready_task,
+      const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+          ready_task,
       const base::Closure& retry_callback);
 
   // Called when the syncer has finished performing a configuration.
   void FinishConfigureDataTypesOnFrontendLoop(
       const syncer::ModelTypeSet enabled_types,
       const syncer::ModelTypeSet succeeded_configuration_types,
       const syncer::ModelTypeSet failed_configuration_types,
-      const base::Callback<void(syncer::ModelTypeSet,
-                                syncer::ModelTypeSet)>& ready_task);
+      const base::Callback<void(syncer::ModelTypeSet, syncer::ModelTypeSet)>&
+          ready_task);
 
   // Reports backend initialization success.  Includes some objects from sync
   // 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 syncer::WeakHandle<syncer::JsBackend> js_backend,
       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>
           debug_info_listener,
@@ skipping 24 matching lines @@
   // explicitly requested that we start forwarding these events.
   void HandleDirectoryStatusCountersUpdatedOnFrontendLoop(
       syncer::ModelType type,
       const syncer::StatusCounters& counters);
 
   // Overwrites the kSyncInvalidationVersions preference with the most recent
   // set of invalidation versions for each type.
   void UpdateInvalidationVersions(
       const std::map<syncer::ModelType, int64_t>& invalidation_versions);
 
-  sync_driver::SyncFrontend* frontend() {
-    return frontend_;
-  }
+  sync_driver::SyncFrontend* frontend() { return frontend_; }
 
  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.
   void HandleInitializationFailureOnFrontendLoop();
 
   // Called from Core::OnSyncCycleCompleted to handle updating frontend
   // thread components.
   void HandleSyncCycleCompletedOnFrontendLoop(
       const syncer::sessions::SyncSessionSnapshot& snapshot);
 
   // Called when the syncer failed to perform a configuration and will
   // eventually retry. FinishingConfigurationOnFrontendLoop(..) will be called
   // on successful completion.
   void RetryConfigurationOnFrontendLoop(const base::Closure& retry_callback);
 
   // 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,
-      syncer::BootstrapTokenType token_type);
+  void PersistEncryptionBootstrapToken(const std::string& token,
+                                       syncer::BootstrapTokenType token_type);
 
   // For convenience, checks if initialization state is INITIALIZED.
   bool initialized() const { return initialized_; }
 
   // Let the front end handle the actionable error event.
   void HandleActionableErrorEventOnFrontendLoop(
       const syncer::SyncProtocolError& sync_error);
 
   // Handle a migration request.
   void HandleMigrationRequestedOnFrontendLoop(const syncer::ModelTypeSet types);
@@ skipping 12 matching lines @@
   // required reason is REASON_ENCRYPTION, an empty EncryptedData object is
   // passed.
   void NotifyPassphraseRequired(syncer::PassphraseRequiredReason reason,
                                 sync_pb::EncryptedData pending_keys);
 
   // Invoked when the passphrase provided by the user has been accepted.
   void NotifyPassphraseAccepted();
 
   // Invoked when the set of encrypted types or the encrypt
   // everything flag changes.
-  void NotifyEncryptedTypesChanged(
-      syncer::ModelTypeSet encrypted_types,
-      bool encrypt_everything);
+  void NotifyEncryptedTypesChanged(syncer::ModelTypeSet encrypted_types,
+                                   bool encrypt_everything);
 
   // Invoked when sync finishes encrypting new datatypes.
   void NotifyEncryptionComplete();
 
   // Invoked when the passphrase state has changed. Caches the passphrase state
   // for later use on the UI thread.
   // If |type| is FROZEN_IMPLICIT_PASSPHRASE or CUSTOM_PASSPHRASE,
   // |explicit_passphrase_time| is the time at which that passphrase was set
   // (if available).
   void HandlePassphraseTypeChangedOnFrontendLoop(
@@ skipping 68 matching lines @@
   bool invalidation_handler_registered_;
 
   base::WeakPtrFactory<SyncBackendHostImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHostImpl);
 };
 
 }  // namespace browser_sync
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_HOST_IMPL_H_