Revert of Sync: Refactoring of DEVICE_INFO syncable type - Part 1

chrome/browser/sync/profile_sync_service.cc

 // 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.
 
 #include "chrome/browser/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 168 matching lines @@
 }  // anonymous namespace
 
 bool ShouldShowActionOnUI(
     const syncer::SyncProtocolError& error) {
   return (error.action != syncer::UNKNOWN_ACTION &&
           error.action != syncer::DISABLE_SYNC_ON_CLIENT &&
           error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT);
 }
 
 ProfileSyncService::ProfileSyncService(
-    scoped_ptr<ProfileSyncComponentsFactory> factory,
+    ProfileSyncComponentsFactory* factory,
     Profile* profile,
     scoped_ptr<SupervisedUserSigninManagerWrapper> signin_wrapper,
     ProfileOAuth2TokenService* oauth2_token_service,
     ProfileSyncServiceStartBehavior start_behavior)
     : OAuth2TokenService::Consumer("sync"),
       last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
-      factory_(factory.Pass()),
+      factory_(factory),
       profile_(profile),
       sync_prefs_(profile_->GetPrefs()),
       sync_service_url_(GetSyncServiceURL(*CommandLine::ForCurrentProcess())),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
       signin_(signin_wrapper.Pass()),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
@@ skipping 26 matching lines @@
                      startup_controller_weak_factory_.GetWeakPtr(),
                      ROLLBACK)),
       backend_mode_(IDLE),
       backup_start_delay_(base::TimeDelta::FromSeconds(kBackupStartDelay)),
       clear_browsing_data_(base::Bind(&ClearBrowsingData)) {
   DCHECK(profile);
   syncer::SyncableService::StartSyncFlare flare(
       sync_start_util::GetFlareForSyncableService(profile->GetPath()));
   scoped_ptr<browser_sync::LocalSessionEventRouter> router(
       new NotificationServiceSessionsRouter(profile, flare));
-
-  DCHECK(factory_.get());
-  local_device_ = factory_->CreateLocalDeviceInfoProvider();
   sessions_sync_manager_.reset(
-      new SessionsSyncManager(profile, local_device_.get(), router.Pass()));
+      new SessionsSyncManager(profile, this, router.Pass()));
 }
 
 ProfileSyncService::~ProfileSyncService() {
   sync_prefs_.RemoveSyncPrefObserver(this);
   // Shutdown() should have been called before destruction.
   CHECK(!backend_initialized_);
 }
 
 bool ProfileSyncService::IsSyncEnabledAndLoggedIn() {
   // Exit if sync is disabled.
@@ skipping 159 matching lines @@
 browser_sync::OpenTabsUIDelegate* ProfileSyncService::GetOpenTabsUIDelegate() {
   if (!IsSessionsDataTypeControllerRunning())
     return NULL;
   return sessions_sync_manager_.get();
 }
 
 browser_sync::FaviconCache* ProfileSyncService::GetFaviconCache() {
   return sessions_sync_manager_->GetFaviconCache();
 }
 
-browser_sync::SyncedWindowDelegatesGetter*
-ProfileSyncService::GetSyncedWindowDelegatesGetter() const {
-  return sessions_sync_manager_->GetSyncedWindowDelegatesGetter();
-}
-
-browser_sync::LocalDeviceInfoProvider*
-ProfileSyncService::GetLocalDeviceInfoProvider() {
-  return local_device_.get();
+scoped_ptr<browser_sync::DeviceInfo>
+ProfileSyncService::GetLocalDeviceInfo() const {
+  if (HasSyncingBackend()) {
+    browser_sync::SyncedDeviceTracker* device_tracker =
+        backend_->GetSyncedDeviceTracker();
+    if (device_tracker)
+      return device_tracker->ReadLocalDeviceInfo();
+  }
+  return scoped_ptr<browser_sync::DeviceInfo>();
 }
 
 scoped_ptr<browser_sync::DeviceInfo>
 ProfileSyncService::GetDeviceInfo(const std::string& client_id) const {
   if (HasSyncingBackend()) {
     browser_sync::SyncedDeviceTracker* device_tracker =
         backend_->GetSyncedDeviceTracker();
     if (device_tracker)
       return device_tracker->ReadDeviceInfo(client_id);
   }
   return scoped_ptr<browser_sync::DeviceInfo>();
 }
 
 ScopedVector<browser_sync::DeviceInfo>
     ProfileSyncService::GetAllSignedInDevices() const {
   ScopedVector<browser_sync::DeviceInfo> devices;
   if (HasSyncingBackend()) {
     browser_sync::SyncedDeviceTracker* device_tracker =
         backend_->GetSyncedDeviceTracker();
     if (device_tracker) {
       // TODO(lipalani) - Make device tracker return a scoped vector.
       device_tracker->GetAllSyncedDeviceInfo(&devices);
     }
   }
   return devices.Pass();
 }
 
+std::string ProfileSyncService::GetLocalSyncCacheGUID() const {
+  if (HasSyncingBackend()) {
+    browser_sync::SyncedDeviceTracker* device_tracker =
+        backend_->GetSyncedDeviceTracker();
+    if (device_tracker) {
+      return device_tracker->cache_guid();
+    }
+  }
+  return std::string();
+}
+
 // Notifies the observer of any device info changes.
 void ProfileSyncService::AddObserverForDeviceInfoChange(
     browser_sync::SyncedDeviceTracker::Observer* observer) {
   if (HasSyncingBackend()) {
     browser_sync::SyncedDeviceTracker* device_tracker =
         backend_->GetSyncedDeviceTracker();
     if (device_tracker) {
       device_tracker->AddObserver(observer);
     }
   }
@@ skipping 579 matching lines @@
     DCHECK(FirstSetupInProgress());
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
-    const std::string& cache_guid,
     bool success) {
   UpdateBackendInitUMA(success);
 
   if (!success) {
     // Something went unexpectedly wrong.  Play it safe: stop syncing at once
     // and surface error UI to alert the user sync has stopped.
     // Keep the directory around for now so that on restart we will retry
     // again and potentially succeed in presence of transient file IO failures
     // or permissions issues, etc.
     //
     // TODO(rlarocque): Consider making this UnrecoverableError less special.
     // Unlike every other UnrecoverableError, it does not delete our sync data.
     // This exception made sense at the time it was implemented, but our new
     // directory corruption recovery mechanism makes it obsolete.  By the time
     // we get here, we will have already tried and failed to delete the
     // directory.  It would be no big deal if we tried to delete it again.
     OnInternalUnrecoverableError(FROM_HERE,
                                  "BackendInitialize failure",
                                  false,
                                  ERROR_REASON_BACKEND_INIT_FAILURE);
     return;
   }
 
   backend_initialized_ = true;
 
   sync_js_controller_.AttachJsBackend(js_backend);
   debug_info_listener_ = debug_info_listener;
 
-  // Initialize local device info.
-  local_device_->Initialize(cache_guid);
-
   // Give the DataTypeControllers a handle to the now initialized backend
   // as a UserShare.
   for (DataTypeController::TypeMap::iterator it =
        directory_data_type_controllers_.begin();
        it != directory_data_type_controllers_.end(); ++it) {
     it->second->OnUserShareReady(GetUserShare());
   }
 
   if (backend_mode_ == BACKUP || backend_mode_ == ROLLBACK)
     ConfigureDataTypeManager();
@@ skipping 1481 matching lines @@
   }
   return result;
 }
 
 void ProfileSyncService::StartStopBackupForTesting() {
   if (backend_mode_ == BACKUP)
     ShutdownImpl(browser_sync::SyncBackendHost::STOP_AND_CLAIM_THREAD);
   else
     backup_rollback_controller_.Start(base::TimeDelta());
 }