[Sync] Componentize synced_tab_delegate

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 <algorithm>
 
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
-#include "chrome/browser/sync/glue/synced_tab_delegate.h"
-#include "chrome/common/url_constants.h"
-#include "components/sessions/content/content_serialized_navigation_builder.h"
 #include "components/sync_driver/glue/synced_window_delegate.h"
 #include "components/sync_driver/local_device_info_provider.h"
 #include "components/sync_driver/sessions/synced_window_delegates_getter.h"
-#include "content/public/browser/favicon_status.h"
-#include "content/public/browser/navigation_entry.h"
+#include "components/sync_sessions/sync_sessions_client.h"
+#include "components/sync_sessions/synced_tab_delegate.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"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/api/time.h"
 
-using content::NavigationEntry;
-using sessions::ContentSerializedNavigationBuilder;
 using sessions::SerializedNavigationEntry;
 using sync_driver::DeviceInfo;
 using sync_driver::LocalDeviceInfoProvider;
 using syncer::SyncChange;
 using syncer::SyncData;
 
 namespace browser_sync {
 
 namespace {
 
@@ skipping 24 matching lines @@
 bool SessionsRecencyComparator(const sync_driver::SyncedSession* s1,
                            const sync_driver::SyncedSession* s2) {
   return s1->modified_time > s2->modified_time;
 }
 
 }  // namespace
 
 // |local_device| is owned by ProfileSyncService, its lifetime exceeds
 // lifetime of SessionSyncManager.
 SessionsSyncManager::SessionsSyncManager(
+    sync_sessions::SyncSessionsClient* sessions_client,
     Profile* profile,
     LocalDeviceInfoProvider* local_device,
-    scoped_ptr<LocalSessionEventRouter> router,
-    scoped_ptr<SyncedWindowDelegatesGetter> synced_window_getter)
-    : favicon_cache_(FaviconServiceFactory::GetForProfile(
+    scoped_ptr<LocalSessionEventRouter> router)
+    : sessions_client_(sessions_client),
+      session_tracker_(sessions_client),
+      favicon_cache_(FaviconServiceFactory::GetForProfile(
                          profile,
                          ServiceAccessType::EXPLICIT_ACCESS),
                      HistoryServiceFactory::GetForProfile(
                          profile,
                          ServiceAccessType::EXPLICIT_ACCESS),
                      kMaxSyncFavicons),
       local_tab_pool_out_of_sync_(true),
       sync_prefs_(profile->GetPrefs()),
       profile_(profile),
       local_device_(local_device),
       local_session_header_node_id_(TabNodePool::kInvalidTabNodeID),
       stale_session_threshold_days_(kDefaultStaleSessionThresholdDays),
       local_event_router_(router.Pass()),
-      synced_window_getter_(synced_window_getter.Pass()),
       page_revisit_broadcaster_(this,
+                                sessions_client,
                                 HistoryServiceFactory::GetForProfile(
                                     profile,
                                     ServiceAccessType::EXPLICIT_ACCESS),
-                                BookmarkModelFactory::GetForProfile(profile)) {}
+                                BookmarkModelFactory::GetForProfile(profile)) {
+  synced_window_getter_ = sessions_client_->GetSyncedWindowDelegatesGetter();
+}
 
 LocalSessionEventRouter::~LocalSessionEventRouter() {}
 
 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";
@@ skipping 86 matching lines @@
   current_session->modified_time = base::Time::Now();
   header_s->set_client_name(current_session_name_);
   // SessionDataTypeController ensures that the local device info
   // is available before activating this datatype.
   DCHECK(local_device_);
   const DeviceInfo* local_device_info = local_device_->GetLocalDeviceInfo();
   header_s->set_device_type(local_device_info->device_type());
 
   session_tracker_.ResetSessionTracking(local_tag);
   std::set<const SyncedWindowDelegate*> windows =
-      synced_window_getter_->GetSyncedWindowDelegates();
+      GetSyncedWindowDelegatesGetter()->GetSyncedWindowDelegates();
 
   for (std::set<const SyncedWindowDelegate*>::const_iterator i =
            windows.begin(); i != windows.end(); ++i) {
     // Make sure the window has tabs and a viewable window. The viewable window
     // check is necessary because, for example, when a browser is closed the
     // destructor is not necessarily run immediately. This means its possible
     // for us to get a handle to a browser that is about to be removed. If
     // the tab count is 0 or the window is NULL, the browser is about to be
     // deleted, so we ignore it.
     if ((*i)->ShouldSync() && (*i)->GetTabCount() && (*i)->HasWindow()) {
@@ skipping 16 matching lines @@
 
       bool found_tabs = false;
       for (int j = 0; j < (*i)->GetTabCount(); ++j) {
         SessionID::id_type tab_id = (*i)->GetTabIdAt(j);
         SyncedTabDelegate* synced_tab = (*i)->GetTabAt(j);
 
         // GetTabAt can return a null tab; in that case just skip it.
         if (!synced_tab)
           continue;
 
-        if (!synced_tab->HasWebContents()) {
+        if (synced_tab->IsPlaceholderTab()) {
           // For tabs without WebContents update the |tab_id|, as it could have
           // changed after a session restore.
           // Note: We cannot check if a tab is valid if it has no WebContents.
           // We assume any such tab is valid and leave the contents of
           // corresponding sync node unchanged.
           if (synced_tab->GetSyncId() > TabNodePool::kInvalidTabNodeID &&
               tab_id > TabNodePool::kInvalidTabID) {
             AssociateRestoredPlaceholderTab(*synced_tab, tab_id,
                                             restored_tabs, change_output);
             found_tabs = true;
@@ skipping 38 matching lines @@
   sync_pb::EntitySpecifics entity;
   entity.mutable_session()->CopyFrom(specifics);
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
         current_machine_tag(), current_session_name_, entity);
   change_output->push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data));
 }
 
 void SessionsSyncManager::AssociateTab(SyncedTabDelegate* const tab,
                                        syncer::SyncChangeList* change_output) {
-  DCHECK(tab->HasWebContents());
+  DCHECK(!tab->IsPlaceholderTab());
   SessionID::id_type tab_id = tab->GetSessionId();
-  if (tab->profile() != profile_)
-    return;
 
   if (tab->IsBeingDestroyed()) {
     // This tab is closing.
     TabLinksMap::iterator tab_iter = local_tab_map_.find(tab_id);
     if (tab_iter == local_tab_map_.end()) {
       // We aren't tracking this tab (for example, sync setting page).
       return;
     }
     local_tab_pool_.FreeTabNode(tab_iter->second->tab_node_id(),
                                 change_output);
     local_tab_map_.erase(tab_iter);
     return;
   }
 
-  if (!tab->ShouldSync())
+  if (!tab->ShouldSync(sessions_client_))
     return;
 
   TabLinksMap::iterator local_tab_map_iter = local_tab_map_.find(tab_id);
   TabLink* tab_link = NULL;
 
   if (local_tab_map_iter == local_tab_map_.end()) {
     int tab_node_id = tab->GetSyncId();
     // If there is an old sync node for the tab, reuse it.  If this is a new
     // tab, get a sync node for it.
     if (!local_tab_pool_.IsUnassociatedTabNode(tab_node_id)) {
@@ skipping 19 matching lines @@
   sync_pb::EntitySpecifics specifics;
   LocalTabDelegateToSpecifics(*tab, specifics.mutable_session());
   syncer::SyncData data = syncer::SyncData::CreateLocalData(
       TabNodePool::TabIdToTag(current_machine_tag_,
                                tab_link->tab_node_id()),
       current_session_name_,
       specifics);
   change_output->push_back(syncer::SyncChange(
       FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data));
 
-  const GURL new_url = GetCurrentVirtualURL(*tab);
+  int current_index = tab->GetCurrentEntryIndex();
+  const GURL new_url = tab->GetVirtualURLAtIndex(current_index);
   if (new_url != tab_link->url()) {
     tab_link->set_url(new_url);
-    favicon_cache_.OnFaviconVisited(new_url, GetCurrentFaviconURL(*tab));
+    favicon_cache_.OnFaviconVisited(new_url,
+                                    tab->GetFaviconURLAtIndex(current_index));
     page_revisit_broadcaster_.OnPageVisit(
-        new_url, tab->GetCurrentEntryMaybePending()->GetTransitionType());
+        new_url, tab->GetTransitionAtIndex(current_index));
   }
 
   session_tracker_.GetSession(current_machine_tag())->modified_time =
       base::Time::Now();
 }
 
 void SessionsSyncManager::RebuildAssociations() {
   syncer::SyncDataList data(
       sync_processor_->GetAllSyncData(syncer::SESSIONS));
   scoped_ptr<syncer::SyncErrorFactory> error_handler(error_handler_.Pass());
@@ skipping 16 matching lines @@
       bool success = session_tab_ids.insert(tab_id).second;
       if (!success)
         return false;
     }
   }
 
   return true;
 }
 
 void SessionsSyncManager::OnLocalTabModified(SyncedTabDelegate* modified_tab) {
-  const content::NavigationEntry* entry = modified_tab->GetActiveEntry();
-  if (!modified_tab->IsBeingDestroyed() &&
-      entry &&

[sdefresne, 2015/10/28 16:36:30]

I think the crash in http://crbug.com/548572  is due to this change.

It is possible that entry is null, but SyncedTabDelegate::GetVirtualURLAtIndex()
never checks that the entry returned by GetPossiblyPendingEntryAtIndex() is non
null.

-      entry->GetVirtualURL().is_valid() &&
-      entry->GetVirtualURL().spec() == kNTPOpenTabSyncURL) {
+  GURL virtual_url =
+      modified_tab->GetVirtualURLAtIndex(modified_tab->GetCurrentEntryIndex());
+  if (!modified_tab->IsBeingDestroyed() && virtual_url.is_valid() &&
+      virtual_url.spec() == kNTPOpenTabSyncURL) {
     DVLOG(1) << "Triggering sync refresh for sessions datatype.";
     const syncer::ModelTypeSet types(syncer::SESSIONS);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
         content::Source<Profile>(profile_),
         content::Details<const syncer::ModelTypeSet>(&types));
   }
 
   if (local_tab_pool_out_of_sync_) {
     // If our tab pool is corrupt, pay the price of a full re-association to
     // fix things up.  This takes care of the new tab modification as well.
     RebuildAssociations();
     DCHECK(!local_tab_pool_out_of_sync_);
     return;
   }
 
   syncer::SyncChangeList changes;
-  // Associate tabs first so the synced session tracker is aware of them.
   AssociateTab(modified_tab, &changes);
   // Note, we always associate windows because it's possible a tab became
   // "interesting" by going to a valid URL, in which case it needs to be added
-  // to the window's tab information.
+  // to the window's tab information. Similarly, if a tab became
+  // "uninteresting", we remove it from the window's tab information.
   AssociateWindows(DONT_RELOAD_TABS, syncer::SyncDataList(), &changes);
   sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 void SessionsSyncManager::OnFaviconsChanged(
     const std::set<GURL>& page_urls,
     const GURL& /* icon_url */) {
   // 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 (const GURL& page_url : page_urls) {
@@ skipping 442 matching lines @@
     const std::string& foreign_session_tag) {
   if (foreign_session_tag == current_machine_tag()) {
     DVLOG(1) << "Local session deleted! Doing nothing until a navigation is "
              << "triggered.";
     return false;
   }
   DVLOG(1) << "Disassociating session " << foreign_session_tag;
   return session_tracker_.DeleteSession(foreign_session_tag);
 }
 
-// static
-GURL SessionsSyncManager::GetCurrentVirtualURL(
-    const SyncedTabDelegate& tab_delegate) {
-  const NavigationEntry* current_entry =
-      tab_delegate.GetCurrentEntryMaybePending();
-  return current_entry->GetVirtualURL();
-}
-
-// static
-GURL SessionsSyncManager::GetCurrentFaviconURL(
-    const SyncedTabDelegate& tab_delegate) {
-  const NavigationEntry* current_entry =
-      tab_delegate.GetCurrentEntryMaybePending();
-  return (current_entry->GetFavicon().valid ?
-          current_entry->GetFavicon().url :
-          GURL());
-}
-
 bool SessionsSyncManager::GetForeignSession(
     const std::string& tag,
     std::vector<const sessions::SessionWindow*>* windows) {
   return session_tracker_.LookupSessionWindows(tag, windows);
 }
 
 bool SessionsSyncManager::GetForeignSessionTabs(
     const std::string& tag,
     std::vector<const sessions::SessionTab*>* tabs) {
   std::vector<const sessions::SessionWindow*> windows;
@@ skipping 35 matching lines @@
 }
 
 void SessionsSyncManager::LocalTabDelegateToSpecifics(
     const SyncedTabDelegate& tab_delegate,
     sync_pb::SessionSpecifics* specifics) {
   sessions::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);
+  SetSessionTabFromDelegate(GetSyncedWindowDelegatesGetter(), tab_delegate,
+                            base::Time::Now(), session_tab);
   SetVariationIds(session_tab);
   sync_pb::SessionTab tab_s = session_tab->ToSyncData();
   specifics->set_session_tag(current_machine_tag_);
   specifics->set_tab_node_id(tab_delegate.GetSyncId());
   specifics->mutable_tab()->CopyFrom(tab_s);
 }
 
 void SessionsSyncManager::AssociateRestoredPlaceholderTab(
     const SyncedTabDelegate& tab_delegate,
     SessionID::id_type new_tab_id,
@@ skipping 37 matching lines @@
         current_session_name_,
         entity);
     change_output->push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_UPDATE, data));
     return;
   }
 }
 
 // static
 void SessionsSyncManager::SetSessionTabFromDelegate(
-      const SyncedTabDelegate& tab_delegate,
-      base::Time mtime,
-      sessions::SessionTab* session_tab) {
+    SyncedWindowDelegatesGetter* synced_window_getter,
+    const SyncedTabDelegate& tab_delegate,
+    base::Time mtime,
+    sessions::SessionTab* session_tab) {
   DCHECK(session_tab);
   session_tab->window_id.set_id(tab_delegate.GetWindowId());
   session_tab->tab_id.set_id(tab_delegate.GetSessionId());
   session_tab->tab_visual_index = 0;
   // Use -1 to indicate that the index hasn't been set properly yet.
   session_tab->current_navigation_index = -1;
-  session_tab->pinned = tab_delegate.IsPinned();
+  const SyncedWindowDelegate* window_delegate =
+      synced_window_getter->FindById(tab_delegate.GetWindowId());
+  session_tab->pinned =
+      window_delegate ? window_delegate->IsTabPinned(&tab_delegate) : false;
   session_tab->extension_app_id = tab_delegate.GetExtensionAppId();
   session_tab->user_agent_override.clear();
   session_tab->timestamp = mtime;
   const int current_index = tab_delegate.GetCurrentEntryIndex();
   const int min_index = std::max(0, current_index - kMaxSyncNavigationCount);
   const int max_index = std::min(current_index + kMaxSyncNavigationCount,
                                  tab_delegate.GetEntryCount());
   bool is_supervised = tab_delegate.ProfileIsSupervised();
   session_tab->navigations.clear();
 
   for (int i = min_index; i < max_index; ++i) {
-    const NavigationEntry* entry = tab_delegate.GetEntryAtIndexMaybePending(i);
-    DCHECK(entry);
-    if (!entry->GetVirtualURL().is_valid())
+    if (!tab_delegate.GetVirtualURLAtIndex(i).is_valid())
       continue;
+    sessions::SerializedNavigationEntry serialized_entry;
+    tab_delegate.GetSerializedNavigationAtIndex(i, &serialized_entry);
 
     // Set current_navigation_index to the index in navigations.
     if (i == current_index)
       session_tab->current_navigation_index = session_tab->navigations.size();
 
-    session_tab->navigations.push_back(
-        ContentSerializedNavigationBuilder::FromNavigationEntry(i, *entry));
+    session_tab->navigations.push_back(serialized_entry);
     if (is_supervised) {
       session_tab->navigations.back().set_blocked_state(
           SerializedNavigationEntry::STATE_ALLOWED);
     }
   }
 
   // If the current navigation is invalid, set the index to the end of the
   // navigation array.
   if (session_tab->current_navigation_index < 0) {
     session_tab->current_navigation_index =
         session_tab->navigations.size() - 1;
   }
 
   if (is_supervised) {
-    const std::vector<const NavigationEntry*>& blocked_navigations =
+    int offset = session_tab->navigations.size();
+    const std::vector<const SerializedNavigationEntry*>& blocked_navigations =
         *tab_delegate.GetBlockedNavigations();
-    int offset = session_tab->navigations.size();
     for (size_t i = 0; i < blocked_navigations.size(); ++i) {
-      session_tab->navigations.push_back(
-          ContentSerializedNavigationBuilder::FromNavigationEntry(
-              i + offset, *blocked_navigations[i]));
+      session_tab->navigations.push_back(*blocked_navigations[i]);
+      session_tab->navigations.back().set_index(offset + i);
       session_tab->navigations.back().set_blocked_state(
           SerializedNavigationEntry::STATE_BLOCKED);
       // TODO(bauerb): Add categories
     }
   }
   session_tab->session_storage_persistent_id.clear();
 }
 
 // static
 void SessionsSyncManager::SetVariationIds(sessions::SessionTab* session_tab) {
   base::FieldTrial::ActiveGroups active_groups;
   base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
   for (const base::FieldTrial::ActiveGroup& group : active_groups) {
     const variations::VariationID id =
         variations::GetGoogleVariationID(variations::CHROME_SYNC_SERVICE,
                                          group.trial_name, group.group_name);
     if (id != variations::EMPTY_ID)
       session_tab->variation_ids.push_back(id);
   }
 }
 
 FaviconCache* SessionsSyncManager::GetFaviconCache() {
   return &favicon_cache_;
 }
 
 SyncedWindowDelegatesGetter*
 SessionsSyncManager::GetSyncedWindowDelegatesGetter() const {
-  return synced_window_getter_.get();
+  return synced_window_getter_;
 }
 
 void SessionsSyncManager::DoGarbageCollection() {
   std::vector<const sync_driver::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;
@@ skipping 11 matching lines @@
                << " with age " << session_age_in_days << ", deleting.";
       DeleteForeignSessionInternal(session_tag, &changes);
     }
   }
 
   if (!changes.empty())
     sync_processor_->ProcessSyncChanges(FROM_HERE, changes);
 }
 
 };  // namespace browser_sync