Revamp TabNavigation class

chrome/browser/sync/glue/session_model_associator.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/glue/session_model_associator.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 238 matching lines @@
             // unrecoverable error.
             return false;
           }
         }
 
         // If the tab is valid, it would have been added to the tracker either
         // by the above AssociateTab call (at association time), or by the
         // change processor calling AssociateTab for all modified tabs.
         // Therefore, we can key whether this window has valid tabs based on
         // the tab's presence in the tracker.
-        const SyncedSessionTab* tab;
+        const SessionTab* tab = NULL;
         if (synced_session_tracker_.LookupSessionTab(local_tag, tab_id, &tab)) {
           found_tabs = true;
           window_s.add_tab(tab_id);
         }
       }
       // Only add a window if it contains valid tabs.
       if (found_tabs) {
         sync_pb::SessionWindow* header_window = header_s->add_window();
         *header_window = window_s;
 
@@ skipping 108 matching lines @@
   DCHECK(CalledOnValidThread());
   const SyncedTabDelegate& tab = *(tab_link->tab());
   const SyncedWindowDelegate& window =
       *SyncedWindowDelegate::FindSyncedWindowDelegateWithId(
           tab.GetWindowId());
   int64 sync_id = tab_link->sync_id();
   GURL old_tab_url = tab_link->url();
 
   // Load the last stored version of this tab so we can compare changes. If this
   // is a new tab, session_tab will be a blank/newly created SessionTab object.
-  SyncedSessionTab* session_tab =
+  SessionTab* session_tab =
       synced_session_tracker_.GetTab(GetCurrentMachineTag(),
                                      tab.GetSessionId());
 
   // We build a clean session tab specifics directly from the tab data.
   sync_pb::SessionTab tab_s;
 
   GURL new_url;
   AssociateTabContents(window, tab, session_tab, &tab_s, &new_url);
 
   // Trigger the favicon load if needed. We do this before opening the write
@@ skipping 47 matching lines @@
 //    by the unique id, and the navigation didn't just become the current
 //    navigation, we preserve the old timestamp.
 // 2. If the navigation exists in both but just become the current navigation
 //    (e.g. the user went back in history to this navigation), we update the
 //    timestamp to Now().
 // 3. All new navigations not present in |prev_tab| have their timestamps set to
 //    Now().
 void SessionModelAssociator::AssociateTabContents(
     const SyncedWindowDelegate& window,
     const SyncedTabDelegate& new_tab,
-    SyncedSessionTab* prev_tab,
+    SessionTab* prev_tab,
     sync_pb::SessionTab* sync_tab,
     GURL* new_url) {
   DCHECK(prev_tab);
   DCHECK(sync_tab);
   DCHECK(new_url);
   SessionID::id_type tab_id = new_tab.GetSessionId();
   sync_tab->set_tab_id(tab_id);
   sync_tab->set_window_id(new_tab.GetWindowId());
   const int current_index = new_tab.GetCurrentEntryIndex();
   sync_tab->set_current_navigation_index(current_index);
   const int min_index = std::max(0,
                                  current_index - kMaxSyncNavigationCount);
   const int max_index = std::min(current_index + kMaxSyncNavigationCount,
                                  new_tab.GetEntryCount());
   const int pending_index = new_tab.GetPendingEntryIndex();
   sync_tab->set_pinned(window.IsTabPinned(&new_tab));
   if (new_tab.HasExtensionAppId()) {
     sync_tab->set_extension_app_id(new_tab.GetExtensionAppId());
   }
 
   sync_tab->mutable_navigation()->Clear();
-  std::vector<SyncedTabNavigation>::const_iterator prev_nav_iter =
-      prev_tab->synced_tab_navigations.begin();
+  std::vector<TabNavigation>::const_iterator prev_nav_iter =
+      prev_tab->navigations.begin();
   for (int i = min_index; i < max_index; ++i) {
     const NavigationEntry* entry = (i == pending_index) ?
        new_tab.GetPendingEntry() : new_tab.GetEntryAtIndex(i);
     DCHECK(entry);
     if (i == min_index) {
       // Find the location of the first navigation within the previous list of
       // navigations. We only need to do this once, as all subsequent
       // navigations are either contiguous or completely new.
-      for (;prev_nav_iter != prev_tab->synced_tab_navigations.end();
+      for (;prev_nav_iter != prev_tab->navigations.end();
            ++prev_nav_iter) {
         if (prev_nav_iter->unique_id() == entry->GetUniqueID())
           break;
       }
     }
     if (entry->GetVirtualURL().is_valid()) {
       if (i == current_index) {
         *new_url = GURL(entry->GetVirtualURL().spec());
         DVLOG(1) << "Associating local tab " << new_tab.GetSessionId()
                  << " with url " << new_url->spec() << " and title "
                  << entry->GetTitle();
 
       }
       sync_pb::TabNavigation* sync_nav = sync_tab->add_navigation();
-      PopulateSessionSpecificsNavigation(*entry, sync_nav);
+      const TabNavigation& navigation =
+          TabNavigation::FromNavigationEntry(i, *entry, base::Time::Now());
+      *sync_nav = navigation.ToSyncData();
 
       // If this navigation is an old one, reuse the old timestamp. Otherwise we
       // leave the timestamp as the current time.
-      if (prev_nav_iter != prev_tab->synced_tab_navigations.end() &&
+      if (prev_nav_iter != prev_tab->navigations.end() &&
           prev_nav_iter->unique_id() == entry->GetUniqueID()) {
         // Check that we haven't gone back/foward in the nav stack to this page
         // (if so, we want to refresh the timestamp).
         if (!(current_index != prev_tab->current_navigation_index &&
               current_index == i)) {
           sync_nav->set_timestamp(
               syncer::TimeToProtoTime(prev_nav_iter->timestamp()));
           DVLOG(2) << "Nav to " << sync_nav->virtual_url() << " already known, "
                    << "reusing old timestamp " << sync_nav->timestamp();
         }
         // Even if the user went back in their history, they may have skipped
         // over navigations, so the subsequent navigation entries may need their
         // old timestamps preserved.
         ++prev_nav_iter;
       } else if (current_index != i &&
-                 prev_tab->synced_tab_navigations.empty()) {
+                 prev_tab->navigations.empty()) {
         // If this is a new tab, and has more than one navigation, we don't
         // actually want to assign the current timestamp to other navigations.
         // Override the timestamp to 0 in that case.
         // Note: this is primarily to handle restoring sessions at restart,
         // opening recently closed tabs, or opening tabs from other devices.
         // Only the current navigation should have a timestamp in those cases.
         sync_nav->set_timestamp(0);
       }
     }
   }
@@ skipping 106 matching lines @@
       // where we rewrite tab specifics every time a favicon changes, since some
       // favicons can in fact be web-controlled/animated.
       if (tab_iter->second->url() == *i &&
           tab_iter->second->favicon_load_handle() != 0) {
         LoadFaviconForTab(tab_iter->second.get());
       }
     }
   }
 }
 
-// Static
-// TODO(zea): perhaps sync state (scroll position, form entries, etc.) as well?
-// See http://crbug.com/67068.
-void SessionModelAssociator::PopulateSessionSpecificsNavigation(
-    const NavigationEntry& navigation,
-    sync_pb::TabNavigation* tab_navigation) {
-  tab_navigation->set_virtual_url(navigation.GetVirtualURL().spec());
-  // FIXME(zea): Support referrer policy?
-  tab_navigation->set_referrer(navigation.GetReferrer().url.spec());
-  tab_navigation->set_title(UTF16ToUTF8(navigation.GetTitle()));
-  switch (navigation.GetTransitionType()) {
-    case content::PAGE_TRANSITION_LINK:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_LINK);
-      break;
-    case content::PAGE_TRANSITION_TYPED:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_TYPED);
-      break;
-    case content::PAGE_TRANSITION_AUTO_BOOKMARK:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_AUTO_BOOKMARK);
-      break;
-    case content::PAGE_TRANSITION_AUTO_SUBFRAME:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_AUTO_SUBFRAME);
-      break;
-    case content::PAGE_TRANSITION_MANUAL_SUBFRAME:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_MANUAL_SUBFRAME);
-      break;
-    case content::PAGE_TRANSITION_GENERATED:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_GENERATED);
-      break;
-    case content::PAGE_TRANSITION_AUTO_TOPLEVEL:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_AUTO_TOPLEVEL);
-      break;
-    case content::PAGE_TRANSITION_FORM_SUBMIT:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_FORM_SUBMIT);
-      break;
-    case content::PAGE_TRANSITION_RELOAD:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_RELOAD);
-      break;
-    case content::PAGE_TRANSITION_KEYWORD:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_KEYWORD);
-      break;
-    case content::PAGE_TRANSITION_KEYWORD_GENERATED:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_KEYWORD_GENERATED);
-      break;
-    case content::PAGE_TRANSITION_CHAIN_START:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_CHAIN_START);
-      break;
-    case content::PAGE_TRANSITION_CHAIN_END:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_CHAIN_END);
-      break;
-    case content::PAGE_TRANSITION_CLIENT_REDIRECT:
-      tab_navigation->set_navigation_qualifier(
-        sync_pb::SyncEnums_PageTransitionQualifier_CLIENT_REDIRECT);
-      break;
-    case content::PAGE_TRANSITION_SERVER_REDIRECT:
-      tab_navigation->set_navigation_qualifier(
-        sync_pb::SyncEnums_PageTransitionQualifier_SERVER_REDIRECT);
-      break;
-    default:
-      tab_navigation->set_page_transition(
-        sync_pb::SyncEnums_PageTransition_TYPED);
-  }
-  tab_navigation->set_unique_id(navigation.GetUniqueID());
-  tab_navigation->set_timestamp(
-      syncer::TimeToProtoTime(base::Time::Now()));
-}
-
 void SessionModelAssociator::Associate(const SyncedTabDelegate* tab,
                                        int64 sync_id) {
   NOTIMPLEMENTED();
 }
 
 void SessionModelAssociator::Disassociate(int64 sync_id) {
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
@@ skipping 279 matching lines @@
                                          modification_time,
                                          foreign_session->windows[window_id],
                                          &synced_session_tracker_);
     }
 
     // Delete any closed windows and unused tabs as necessary.
     synced_session_tracker_.CleanupSession(foreign_session_tag);
   } else if (specifics.has_tab()) {
     const sync_pb::SessionTab& tab_s = specifics.tab();
     SessionID::id_type tab_id = tab_s.tab_id();
-    SyncedSessionTab* tab =
+    SessionTab* tab =
         synced_session_tracker_.GetTab(foreign_session_tag, tab_id);
 
     // Figure out what the previous url for this tab was (may be empty string
     // if this is a new tab).
     std::string previous_url;
     if (tab->navigations.size() > 0) {
       int selected_index = tab->current_navigation_index;
       selected_index = std::max(
           0,
           std::min(selected_index,
@@ skipping 138 matching lines @@
                             session_window->window_id.id(),
                             tab_id,
                             i);
   }
 }
 
 // Static
 void SessionModelAssociator::PopulateSessionTabFromSpecifics(
     const sync_pb::SessionTab& specifics,
     const base::Time& mtime,
-    SyncedSessionTab* tab) {
+    SessionTab* tab) {
   DCHECK_EQ(tab->tab_id.id(), specifics.tab_id());
   if (specifics.has_tab_id())
     tab->tab_id.set_id(specifics.tab_id());
   if (specifics.has_window_id())
     tab->window_id.set_id(specifics.window_id());
   if (specifics.has_tab_visual_index())
     tab->tab_visual_index = specifics.tab_visual_index();
   if (specifics.has_current_navigation_index())
     tab->current_navigation_index = specifics.current_navigation_index();
   if (specifics.has_pinned())
     tab->pinned = specifics.pinned();
   if (specifics.has_extension_app_id())
     tab->extension_app_id = specifics.extension_app_id();
   tab->timestamp = mtime;
   // Cleared in case we reuse a pre-existing SyncedSessionTab object.
   tab->navigations.clear();
-  tab->synced_tab_navigations.clear();
   for (int i = 0; i < specifics.navigation_size(); ++i) {
-    AppendSessionTabNavigation(specifics.navigation(i),
-                               tab);
+    tab->navigations.push_back(
+        TabNavigation::FromSyncData(i, specifics.navigation(i)));
   }
 }
 
-// Static
-void SessionModelAssociator::AppendSessionTabNavigation(
-    const sync_pb::TabNavigation& specifics,
-    SyncedSessionTab* tab) {
-  int index = 0;
-  GURL virtual_url;
-  GURL referrer;
-  string16 title;
-  std::string state;
-  content::PageTransition transition(content::PAGE_TRANSITION_LINK);
-  base::Time timestamp;
-  int unique_id = 0;
-  if (specifics.has_virtual_url()) {
-    GURL gurl(specifics.virtual_url());
-    virtual_url = gurl;
-  }
-  if (specifics.has_referrer()) {
-    GURL gurl(specifics.referrer());
-    referrer = gurl;
-  }
-  if (specifics.has_title())
-    title = UTF8ToUTF16(specifics.title());
-  if (specifics.has_state())
-    state = specifics.state();
-  if (specifics.has_page_transition() ||
-      specifics.has_navigation_qualifier()) {
-    switch (specifics.page_transition()) {
-      case sync_pb::SyncEnums_PageTransition_LINK:
-        transition = content::PAGE_TRANSITION_LINK;
-        break;
-      case sync_pb::SyncEnums_PageTransition_TYPED:
-        transition = content::PAGE_TRANSITION_TYPED;
-        break;
-      case sync_pb::SyncEnums_PageTransition_AUTO_BOOKMARK:
-        transition = content::PAGE_TRANSITION_AUTO_BOOKMARK;
-        break;
-      case sync_pb::SyncEnums_PageTransition_AUTO_SUBFRAME:
-        transition = content::PAGE_TRANSITION_AUTO_SUBFRAME;
-        break;
-      case sync_pb::SyncEnums_PageTransition_MANUAL_SUBFRAME:
-        transition = content::PAGE_TRANSITION_MANUAL_SUBFRAME;
-        break;
-      case sync_pb::SyncEnums_PageTransition_GENERATED:
-        transition = content::PAGE_TRANSITION_GENERATED;
-        break;
-      case sync_pb::SyncEnums_PageTransition_AUTO_TOPLEVEL:
-        transition = content::PAGE_TRANSITION_AUTO_TOPLEVEL;
-        break;
-      case sync_pb::SyncEnums_PageTransition_FORM_SUBMIT:
-        transition = content::PAGE_TRANSITION_FORM_SUBMIT;
-        break;
-      case sync_pb::SyncEnums_PageTransition_RELOAD:
-        transition = content::PAGE_TRANSITION_RELOAD;
-        break;
-      case sync_pb::SyncEnums_PageTransition_KEYWORD:
-        transition = content::PAGE_TRANSITION_KEYWORD;
-        break;
-      case sync_pb::SyncEnums_PageTransition_KEYWORD_GENERATED:
-        transition = content::PAGE_TRANSITION_KEYWORD_GENERATED;
-        break;
-      case sync_pb::SyncEnums_PageTransition_CHAIN_START:
-        transition = content::PAGE_TRANSITION_CHAIN_START;
-        break;
-      case sync_pb::SyncEnums_PageTransition_CHAIN_END:
-        transition = content::PAGE_TRANSITION_CHAIN_END;
-        break;
-      default:
-        switch (specifics.navigation_qualifier()) {
-          case sync_pb::SyncEnums_PageTransitionQualifier_CLIENT_REDIRECT:
-            transition = content::PAGE_TRANSITION_CLIENT_REDIRECT;
-            break;
-            case sync_pb::SyncEnums_PageTransitionQualifier_SERVER_REDIRECT:
-            transition = content::PAGE_TRANSITION_SERVER_REDIRECT;
-              break;
-            default:
-            transition = content::PAGE_TRANSITION_TYPED;
-        }
-    }
-  }
-  if (specifics.has_timestamp()) {
-    timestamp = syncer::ProtoTimeToTime(specifics.timestamp());
-  }
-  if (specifics.has_unique_id()) {
-    unique_id = specifics.unique_id();
-  }
-  SyncedTabNavigation tab_navigation(
-      index, virtual_url,
-      content::Referrer(referrer, WebKit::WebReferrerPolicyDefault), title,
-      state, transition, unique_id, timestamp);
-  // We insert it twice, once for our SyncedTabNavigations, once for the normal
-  // TabNavigation (used by the session restore UI).
-  tab->synced_tab_navigations.insert(tab->synced_tab_navigations.end(),
-                                     tab_navigation);
-  tab->navigations.insert(tab->navigations.end(),
-                          tab_navigation);
-}
-
 void SessionModelAssociator::LoadForeignTabFavicon(
     const sync_pb::SessionTab& tab) {
   if (!tab.has_favicon() || tab.favicon().empty())
     return;
   if (!tab.has_favicon_type() ||
       tab.favicon_type() != sync_pb::SessionTab::TYPE_WEB_FAVICON) {
     DVLOG(1) << "Ignoring non-web favicon.";
     return;
   }
   if (tab.navigation_size() == 0)
@@ skipping 124 matching lines @@
     std::vector<const SessionWindow*>* windows) {
   DCHECK(CalledOnValidThread());
   return synced_session_tracker_.LookupSessionWindows(tag, windows);
 }
 
 bool SessionModelAssociator::GetForeignTab(
     const std::string& tag,
     const SessionID::id_type tab_id,
     const SessionTab** tab) {
   DCHECK(CalledOnValidThread());
-  const SyncedSessionTab* synced_tab;
+  const SessionTab* synced_tab = NULL;
   bool success = synced_session_tracker_.LookupSessionTab(tag,
                                                           tab_id,
                                                           &synced_tab);
   if (success)
     *tab = synced_tab;
   return success;
 }
 
 void SessionModelAssociator::DeleteStaleSessions() {
   DCHECK(CalledOnValidThread());
@@ skipping 133 matching lines @@
 
 bool SessionModelAssociator::CryptoReadyIfNecessary() {
   // We only access the cryptographer while holding a transaction.
   syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   const syncer::ModelTypeSet encrypted_types = trans.GetEncryptedTypes();
   return !encrypted_types.Has(SESSIONS) ||
          sync_service_->IsCryptographerReady(&trans);
 }
 
 }  // namespace browser_sync