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

chrome/browser/sync/sessions/sessions_sync_manager.cc

 // Copyright 2014 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/sessions/sessions_sync_manager.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/sync/glue/local_device_info_provider.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.h"
 #include "chrome/browser/sync/sessions/sessions_util.h"
 #include "chrome/browser/sync/sessions/synced_window_delegates_getter.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 18 matching lines @@
 static const int kMaxSyncNavigationCount = 6;
 
 // The URL at which the set of synced tabs is displayed. We treat it differently
 // from all other URL's as accessing it triggers a sync refresh of Sessions.
 static const char kNTPOpenTabSyncURL[] = "chrome://newtab/#open_tabs";
 
 // Default number of days without activity after which a session is considered
 // stale and becomes a candidate for garbage collection.
 static const size_t kDefaultStaleSessionThresholdDays = 14;  // 2 weeks.
 
-// |local_device| is owned by ProfileSyncService, its lifetime exceeds
-// lifetime of SessionSyncManager.
 SessionsSyncManager::SessionsSyncManager(
     Profile* profile,
-    LocalDeviceInfoProvider* local_device,
+    SyncInternalApiDelegate* delegate,
     scoped_ptr<LocalSessionEventRouter> router)
     : favicon_cache_(profile, kMaxSyncFavicons),
       local_tab_pool_out_of_sync_(true),
       sync_prefs_(profile->GetPrefs()),
       profile_(profile),
-      local_device_(local_device),
+      delegate_(delegate),
       local_session_header_node_id_(TabNodePool::kInvalidTabNodeID),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       local_event_router_(router.Pass()),
       synced_window_getter_(new SyncedWindowDelegatesGetter()) {
 }
 
 LocalSessionEventRouter::~LocalSessionEventRouter() {}
 
 SessionsSyncManager::~SessionsSyncManager() {
 }
@@ skipping 12 matching lines @@
      scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
      scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   syncer::SyncMergeResult merge_result(type);
   DCHECK(session_tracker_.Empty());
   DCHECK_EQ(0U, local_tab_pool_.Capacity());
 
   error_handler_ = error_handler.Pass();
   sync_processor_ = sync_processor.Pass();
 
   local_session_header_node_id_ = TabNodePool::kInvalidTabNodeID;
+  scoped_ptr<DeviceInfo> local_device_info(delegate_->GetLocalDeviceInfo());
+  syncer::SyncChangeList new_changes;
 
   // Make sure we have a machine tag.  We do this now (versus earlier) as it's
   // a conveniently safe time to assert sync is ready and the cache_guid is
   // initialized.
-  if (current_machine_tag_.empty()) {
+  if (current_machine_tag_.empty())
     InitializeCurrentMachineTag();
-  }
-
-  // SessionDataTypeController ensures that the local device info
-  // is available before activating this datatype.
-  DCHECK(local_device_);
-  const DeviceInfo* local_device_info = local_device_->GetLocalDeviceInfo();
   if (local_device_info) {
     current_session_name_ = local_device_info->client_name();
   } else {
     merge_result.set_error(error_handler_->CreateAndUploadError(
         FROM_HERE,
-        "Failed to get local device info."));
+        "Failed to get device info for machine tag."));
     return merge_result;
   }
-
   session_tracker_.SetLocalSessionTag(current_machine_tag_);
 
-  syncer::SyncChangeList new_changes;
-
   // First, we iterate over sync data to update our session_tracker_.
   syncer::SyncDataList restored_tabs;
   if (!InitFromSyncModel(initial_sync_data, &restored_tabs, &new_changes)) {
     // The sync db didn't have a header node for us. Create one.
     sync_pb::EntitySpecifics specifics;
     sync_pb::SessionSpecifics* base_specifics = specifics.mutable_session();
     base_specifics->set_session_tag(current_machine_tag());
     sync_pb::SessionHeader* header_s = base_specifics->mutable_header();
     header_s->set_client_name(current_session_name_);
     header_s->set_device_type(DeviceInfo::GetLocalDeviceType());
     syncer::SyncData data = syncer::SyncData::CreateLocalData(
         current_machine_tag(), current_session_name_, specifics);
     new_changes.push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_ADD, data));
   }
 
 #if defined(OS_ANDROID)
   std::string sync_machine_tag(BuildMachineTag(
-      local_device_->GetLocalSyncCacheGUID()));
+      delegate_->GetLocalSyncCacheGUID()));
   if (current_machine_tag_.compare(sync_machine_tag) != 0)
     DeleteForeignSessionInternal(sync_machine_tag, &new_changes);
 #endif
 
   // Check if anything has changed on the local client side.
   AssociateWindows(RELOAD_TABS, restored_tabs, &new_changes);
   local_tab_pool_out_of_sync_ = false;
 
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
@@ skipping 497 matching lines @@
 }
 
 void SessionsSyncManager::InitializeCurrentMachineTag() {
   DCHECK(current_machine_tag_.empty());
   std::string persisted_guid;
   persisted_guid = sync_prefs_.GetSyncSessionsGUID();
   if (!persisted_guid.empty()) {
     current_machine_tag_ = persisted_guid;
     DVLOG(1) << "Restoring persisted session sync guid: " << persisted_guid;
   } else {
-    DCHECK(local_device_);
-    std::string cache_guid = local_device_->GetLocalSyncCacheGUID();
-    DCHECK(!cache_guid.empty());
-    current_machine_tag_ = BuildMachineTag(cache_guid);
+    current_machine_tag_ = BuildMachineTag(delegate_->GetLocalSyncCacheGUID());
     DVLOG(1) << "Creating session sync guid: " << current_machine_tag_;
     sync_prefs_.SetSyncSessionsGUID(current_machine_tag_);
   }
 
   local_tab_pool_.SetMachineTag(current_machine_tag_);
 }
 
 // static
 void SessionsSyncManager::PopulateSessionHeaderFromSpecifics(
     const sync_pb::SessionHeader& header_specifics,
@@ skipping 294 matching lines @@
       // TODO(bauerb): Add categories
     }
   }
   session_tab->session_storage_persistent_id.clear();
 }
 
 FaviconCache* SessionsSyncManager::GetFaviconCache() {
   return &favicon_cache_;
 }
 
-SyncedWindowDelegatesGetter*
-SessionsSyncManager::GetSyncedWindowDelegatesGetter() const {
-  return synced_window_getter_.get();
-}
-
 void SessionsSyncManager::DoGarbageCollection() {
   std::vector<const SyncedSession*> sessions;
   if (!GetAllForeignSessions(&sessions))
     return;  // No foreign sessions.
 
   // Iterate through all the sessions and delete any with age older than
   // |stale_session_threshold_days_|.
   syncer::SyncChangeList changes;
   for (std::vector<const SyncedSession*>::const_iterator iter =
            sessions.begin(); iter != sessions.end(); ++iter) {
     const SyncedSession* session = *iter;
     int session_age_in_days =
         (base::Time::Now() - session->modified_time).InDays();
     std::string session_tag = session->session_tag;
     if (session_age_in_days > 0 &&  // If false, local clock is not trustworty.
         static_cast<size_t>(session_age_in_days) >
             stale_session_threshold_days_) {
       DVLOG(1) << "Found stale session " << session_tag
                << " with age " << session_age_in_days << ", deleting.";
       DeleteForeignSessionInternal(session_tag, &changes);
     }
   }
 
   if (!changes.empty())
     sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 };  // namespace browser_sync