Sync: Refactoring of DEVICE_INFO syncable type - Part 1

chrome/browser/sync/profile_sync_service.h

 // Copyright (c) 2012 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_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/sync/backend_unrecoverable_error_handler.h"
 #include "chrome/browser/sync/backup_rollback_controller.h"
+#include "chrome/browser/sync/glue/local_device_info_provider.h"
 #include "chrome/browser/sync/glue/sync_backend_host.h"
 #include "chrome/browser/sync/glue/synced_device_tracker.h"
 #include "chrome/browser/sync/profile_sync_service_base.h"
 #include "chrome/browser/sync/profile_sync_service_observer.h"
 #include "chrome/browser/sync/protocol_event_observer.h"
 #include "chrome/browser/sync/sessions/sessions_sync_manager.h"
 #include "chrome/browser/sync/startup_controller.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/sync_driver/data_type_controller.h"
@@ skipping 46 matching lines @@
 struct StatusCounters;
 struct SyncCredentials;
 struct UpdateCounters;
 struct UserShare;
 }  // namespace syncer
 
 namespace sync_pb {
 class EncryptedData;
 }  // namespace sync_pb
 
+using browser_sync::LocalDeviceInfoProvider;
 using browser_sync::SessionsSyncManager;
 
 // ProfileSyncService is the layer between browser subsystems like bookmarks,
 // and the sync backend.  Each subsystem is logically thought of as being
 // a sync datatype.
 //
 // Individual datatypes can, at any point, be in a variety of stages of being
 // "enabled".  Here are some specific terms for concepts used in this class:
 //
 //   'Registered' (feature suppression for a datatype)
@@ skipping 74 matching lines @@
 //
 class ProfileSyncService : public ProfileSyncServiceBase,
                            public browser_sync::SyncFrontend,
                            public sync_driver::SyncPrefObserver,
                            public browser_sync::DataTypeManagerObserver,
                            public syncer::UnrecoverableErrorHandler,
                            public KeyedService,
                            public browser_sync::DataTypeEncryptionHandler,
                            public OAuth2TokenService::Consumer,
                            public OAuth2TokenService::Observer,
-                           public SessionsSyncManager::SyncInternalApiDelegate,
                            public SigninManagerBase::Observer {
  public:
   typedef browser_sync::SyncBackendHost::Status Status;
 
   // Status of sync server connection, sync token and token request.
   struct SyncTokenStatus {
     SyncTokenStatus();
     ~SyncTokenStatus();
 
     // Sync server connection status reported by sync backend.
@@ skipping 62 matching lines @@
     ROLLBACK    // Backend for rollback.
   };
 
   // Default sync server URL.
   static const char* kSyncServerUrl;
   // Sync server URL for dev channel users
   static const char* kDevServerUrl;
 
   // Takes ownership of |factory| and |signin_wrapper|.
   ProfileSyncService(
-      ProfileSyncComponentsFactory* factory,
+      scoped_ptr<ProfileSyncComponentsFactory> factory,
       Profile* profile,
       scoped_ptr<SupervisedUserSigninManagerWrapper> signin_wrapper,
       ProfileOAuth2TokenService* oauth2_token_service,
       browser_sync::ProfileSyncServiceStartBehavior start_behavior);
   virtual ~ProfileSyncService();
 
   // Initializes the object. This must be called at most once, and
   // immediately after an object of this class is constructed.
   void Initialize();
 
@@ skipping 65 matching lines @@
   // in a message that allows the component to delete its local sync state.
   void InitializeNonBlockingType(
       syncer::ModelType type,
       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
       const base::WeakPtr<syncer::ModelTypeSyncProxyImpl>& proxy);
 
   // Return the active OpenTabsUIDelegate. If sessions is not enabled or not
   // currently syncing, returns NULL.
   virtual browser_sync::OpenTabsUIDelegate* GetOpenTabsUIDelegate();
 
+  // Returns the SyncedWindowDelegatesGetter from the embedded sessions manager.
+  virtual browser_sync::SyncedWindowDelegatesGetter*
+  GetSyncedWindowDelegatesGetter() const;
+
   // Returns the SyncableService for syncer::SESSIONS.
   virtual syncer::SyncableService* GetSessionsSyncableService();
 
-  // SyncInternalApiDelegate implementation.
-  //
-  // Returns sync's representation of the local device info.
-  // Return value is an empty scoped_ptr if the device info is unavailable.
-  virtual scoped_ptr<browser_sync::DeviceInfo> GetLocalDeviceInfo()
-      const OVERRIDE;
-
-  // Gets the guid for the local device. Can be used by other layers to
-  // to distinguish sync data that belongs to the local device vs data
-  // that belongs to remote devices. Returns empty string if sync is not
-  // initialized. The GUID is not persistent across Chrome signout/signin.
-  // If you sign out of Chrome and sign in, a new GUID is generated.
-  virtual std::string GetLocalSyncCacheGUID() const OVERRIDE;
+  // Returns DeviceInfo provider for the local device.
+  virtual browser_sync::LocalDeviceInfoProvider* GetLocalDeviceInfoProvider();
 
   // Returns sync's representation of the device info for a client identified
   // by |client_id|. Return value is an empty scoped ptr if the device info
   // is unavailable.
   virtual scoped_ptr<browser_sync::DeviceInfo> GetDeviceInfo(
       const std::string& client_id) const;
 
   // Gets the device info for all devices signed into the account associated
   // with this profile.
   virtual ScopedVector<browser_sync::DeviceInfo> GetAllSignedInDevices() const;
@@ skipping 15 matching lines @@
   virtual void DisableForUser();
 
   // Disables sync for the user and prevents it from starting on next restart.
   virtual void StopSyncingPermanently();
 
   // SyncFrontend implementation.
   virtual void OnBackendInitialized(
       const syncer::WeakHandle<syncer::JsBackend>& js_backend,
       const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
           debug_info_listener,
+      const std::string& cache_guid,
       bool success) OVERRIDE;
   virtual void OnSyncCycleCompleted() OVERRIDE;
   virtual void OnProtocolEvent(const syncer::ProtocolEvent& event) OVERRIDE;
   virtual void OnDirectoryTypeCommitCounterUpdated(
       syncer::ModelType type,
       const syncer::CommitCounters& counters) OVERRIDE;
   virtual void OnDirectoryTypeUpdateCounterUpdated(
       syncer::ModelType type,
       const syncer::UpdateCounters& counters) OVERRIDE;
   virtual void OnDirectoryTypeStatusCounterUpdated(
@@ skipping 684 matching lines @@
   base::WeakPtrFactory<ProfileSyncService> startup_controller_weak_factory_;
 
   // States related to sync token and connection.
   base::Time connection_status_update_time_;
   syncer::ConnectionStatus connection_status_;
   base::Time token_request_time_;
   base::Time token_receive_time_;
   GoogleServiceAuthError last_get_token_error_;
   base::Time next_token_request_time_;
 
+  scoped_ptr<LocalDeviceInfoProvider> local_device_;
+
   // Locally owned SyncableService implementations.
   scoped_ptr<SessionsSyncManager> sessions_sync_manager_;
 
   scoped_ptr<syncer::NetworkResources> network_resources_;
 
   browser_sync::StartupController startup_controller_;
 
   browser_sync::BackupRollbackController backup_rollback_controller_;
 
   // Mode of current backend.
   BackendMode backend_mode_;
 
   // When browser starts, delay sync backup/rollback backend start for this
   // time.
   base::TimeDelta backup_start_delay_;
 
   base::Callback<void(Profile*, base::Time, base::Time)> clear_browsing_data_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error);
 
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_