sync: Add --enable-sync-sessions-v2 and necessary plumbing to use SessionsSyncManager.

chrome/browser/sync/sessions2/sessions_sync_manager.cc

 // 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.
 
 #include "chrome/browser/sync/sessions2/sessions_sync_manager.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #if !defined(OS_ANDROID)
 #include "chrome/browser/network_time/navigation_time_helper.h"
 #endif
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/sync/glue/synced_window_delegate.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"
 #include "content/public/common/url_constants.h"
 #include "sync/api/sync_error.h"
@@ skipping 10 matching lines @@
 
 // Maximum number of favicons to sync.
 // TODO(zea): pull this from the server.
 static const int kMaxSyncFavicons = 200;
 
 // The maximum number of navigations in each direction we care to sync.
 static const int kMaxSyncNavigationCount = 6;
 
 SessionsSyncManager::SessionsSyncManager(
     Profile* profile,
-    scoped_ptr<SyncPrefs> sync_prefs,
     SyncInternalApiDelegate* delegate)
     : favicon_cache_(profile, kMaxSyncFavicons),
+      sync_prefs_(profile->GetPrefs()),
       profile_(profile),
       delegate_(delegate),
       local_session_header_node_id_(TabNodePool2::kInvalidTabNodeID) {
-  sync_prefs_ = sync_prefs.Pass();
 }
 
 SessionsSyncManager::~SessionsSyncManager() {
 }
 
 // Returns the GUID-based string that should be used for
 // |SessionsSyncManager::current_machine_tag_|.
 static std::string BuildMachineTag(const std::string& cache_guid) {
   std::string machine_tag = "session_sync";
   machine_tag.append(cache_guid);
@@ skipping 40 matching lines @@
     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(delegate_->GetCacheGuid()));
+  std::string sync_machine_tag(BuildMachineTag(
+      delegate_->GetLocalSyncCacheGUID()));
   if (current_machine_tag_.compare(sync_machine_tag) != 0)
-    DeleteForeignSession(sync_machine_tag, &new_changes);
+    DeleteForeignSessionInternal(sync_machine_tag, &new_changes);
 #endif
 
   // Check if anything has changed on the local client side.
   AssociateWindows(RELOAD_TABS, &new_changes);
 
   merge_result.set_error(
       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
   return merge_result;
 }
 
@@ skipping 218 matching lines @@
 // static.
 bool SessionsSyncManager::ShouldSyncWindow(
     const SyncedWindowDelegate* window) {
   if (window->IsApp())
     return false;
   return window->IsTypeTabbed() || window->IsTypePopup();
 }
 
 void SessionsSyncManager::ForwardRelevantFaviconUpdatesToFaviconCache(
     const std::set<GURL>& updated_favicon_page_urls) {
-  NOTIMPLEMENTED() <<
-      "TODO(tim): SessionModelAssociator::FaviconsUpdated equivalent.";
+  // TODO(zea): consider a separate container for tabs with outstanding favicon
+  // loads so we don't have to iterate through all tabs comparing urls.
+  for (std::set<GURL>::const_iterator i = updated_favicon_page_urls.begin();
+       i != updated_favicon_page_urls.end(); ++i) {
+    for (TabLinksMap::iterator tab_iter = local_tab_map_.begin();
+         tab_iter != local_tab_map_.end();
+         ++tab_iter) {
+      if (tab_iter->second->url() == *i)
+        favicon_cache_.OnPageFaviconUpdated(*i);
+    }
+  }
 }
 
 void SessionsSyncManager::StopSyncing(syncer::ModelType type) {
   NOTIMPLEMENTED();
 }
 
 syncer::SyncDataList SessionsSyncManager::GetAllSyncData(
     syncer::ModelType type) const {
   NOTIMPLEMENTED();
   return syncer::SyncDataList();
@@ skipping 183 matching lines @@
       foreign_session->modified_time = modification_time;
   } else {
     LOG(WARNING) << "Ignoring foreign session node with missing header/tab "
                  << "fields and tag " << foreign_session_tag << ".";
   }
 }
 
 void SessionsSyncManager::InitializeCurrentMachineTag() {
   DCHECK(current_machine_tag_.empty());
   std::string persisted_guid;
-  persisted_guid = sync_prefs_->GetSyncSessionsGUID();
+  persisted_guid = sync_prefs_.GetSyncSessionsGUID();
   if (!persisted_guid.empty()) {
     current_machine_tag_ = persisted_guid;
     DVLOG(1) << "Restoring persisted session sync guid: " << persisted_guid;
   } else {
-    current_machine_tag_ = BuildMachineTag(delegate_->GetCacheGuid());
+    current_machine_tag_ = BuildMachineTag(delegate_->GetLocalSyncCacheGUID());
     DVLOG(1) << "Creating session sync guid: " << current_machine_tag_;
-    sync_prefs_->SetSyncSessionsGUID(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,
     base::Time mtime,
     SyncedSession* session_header) {
@@ skipping 74 matching lines @@
     }
   }
 }
 
 bool SessionsSyncManager::GetSyncedFaviconForPageURL(
     const std::string& page_url,
     scoped_refptr<base::RefCountedMemory>* favicon_png) const {
   return favicon_cache_.GetSyncedFaviconForPageURL(GURL(page_url), favicon_png);
 }
 
-void SessionsSyncManager::DeleteForeignSession(
+void SessionsSyncManager::DeleteForeignSession(const std::string& tag) {
+  syncer::SyncChangeList changes;
+  DeleteForeignSessionInternal(tag, &changes);
+  sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
+}
+
+void SessionsSyncManager::DeleteForeignSessionInternal(
     const std::string& tag, syncer::SyncChangeList* change_output) {
  if (tag == current_machine_tag()) {
     LOG(ERROR) << "Attempting to delete local session. This is not currently "
                << "supported.";
     return;
   }
 
   std::set<int> tab_node_ids_to_delete;
   session_tracker_.LookupTabNodeIds(tag, &tab_node_ids_to_delete);
   if (!DisassociateForeignSession(tag)) {
@@ skipping 48 matching lines @@
   const int pending_index = tab_delegate.GetPendingEntryIndex();
   const NavigationEntry* current_entry =
       (current_index == pending_index) ?
       tab_delegate.GetPendingEntry() :
       tab_delegate.GetEntryAtIndex(current_index);
   return (current_entry->GetFavicon().valid ?
           current_entry->GetFavicon().url :
           GURL());
 }
 
+bool SessionsSyncManager::GetForeignSession(
+    const std::string& tag,
+    std::vector<const SessionWindow*>* windows) {
+  return session_tracker_.LookupSessionWindows(tag, windows);
+}
+
+bool SessionsSyncManager::GetForeignTab(
+    const std::string& tag,
+    const SessionID::id_type tab_id,
+    const SessionTab** tab) {
+  const SessionTab* synced_tab = NULL;
+  bool success = session_tracker_.LookupSessionTab(tag,
+                                                   tab_id,
+                                                   &synced_tab);
+  if (success)
+    *tab = synced_tab;
+  return success;
+}
+
 void SessionsSyncManager::LocalTabDelegateToSpecifics(
     const SyncedTabDelegate& tab_delegate,
     sync_pb::SessionSpecifics* specifics) {
   SessionTab* session_tab = NULL;
   session_tab =
       session_tracker_.GetTab(current_machine_tag(),
                               tab_delegate.GetSessionId(),
                               tab_delegate.GetSyncId());
   SetSessionTabFromDelegate(tab_delegate, base::Time::Now(), session_tab);
   sync_pb::SessionTab tab_s = session_tab->ToSyncData();
@@ skipping 91 matching lines @@
           SerializedNavigationEntry::FromNavigationEntry(
               i + offset, *blocked_navigations[i]));
       session_tab->navigations.back().set_blocked_state(
           SerializedNavigationEntry::STATE_BLOCKED);
       // TODO(bauerb): Add categories
     }
   }
   session_tab->session_storage_persistent_id.clear();
 }
 
+
+FaviconCache* SessionsSyncManager::GetFaviconCache() {
+  return &favicon_cache_;
+}
+
 };  // namespace browser_sync