Moves TabNavigation into components/sessions and renames

chrome/browser/sessions/session_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/sessions/session_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 31 matching lines @@
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_mac.h"
 #endif
 
 using base::Time;
 using content::NavigationEntry;
 using content::WebContents;
+using sessions::SerializedNavigationEntry;
 
 // Identifier for commands written to file.
 static const SessionCommand::id_type kCommandSetTabWindow = 0;
 // OBSOLETE Superseded by kCommandSetWindowBounds3.
 // static const SessionCommand::id_type kCommandSetWindowBounds = 1;
 static const SessionCommand::id_type kCommandSetTabIndexInWindow = 2;
 // Original kCommandTabClosed/kCommandWindowClosed. See comment in
 // MigrateClosedPayload for details on why they were replaced.
 static const SessionCommand::id_type kCommandTabClosedObsolete = 3;
 static const SessionCommand::id_type kCommandWindowClosedObsolete = 4;
@@ skipping 345 matching lines @@
   SessionCommand* command =
       new SessionCommand(kCommandTabNavigationPathPrunedFromFront,
                          sizeof(payload));
   memcpy(command->contents(), &payload, sizeof(payload));
   ScheduleCommand(command);
 }
 
 void SessionService::UpdateTabNavigation(
     const SessionID& window_id,
     const SessionID& tab_id,
-    const TabNavigation& navigation) {
+    const SerializedNavigationEntry& navigation) {
   if (!ShouldTrackEntry(navigation.virtual_url()) ||
       !ShouldTrackChangesToWindow(window_id)) {
     return;
   }
 
   if (tab_to_available_range_.find(tab_id.id()) !=
       tab_to_available_range_.end()) {
     std::pair<int, int>& range = tab_to_available_range_[tab_id.id()];
     range.first = std::min(navigation.index(), range.first);
     range.second = std::max(navigation.index(), range.second);
@@ skipping 186 matching lines @@
 
     case content::NOTIFICATION_NAV_ENTRY_CHANGED: {
       WebContents* web_contents =
           content::Source<content::NavigationController>(source).ptr()->
               GetWebContents();
       SessionTabHelper* session_tab_helper =
           SessionTabHelper::FromWebContents(web_contents);
       if (!session_tab_helper || web_contents->GetBrowserContext() != profile())
         return;
       content::Details<content::EntryChangedDetails> changed(details);
-      const TabNavigation navigation =
-          TabNavigation::FromNavigationEntry(
+      const SerializedNavigationEntry navigation =
+          SerializedNavigationEntry::FromNavigationEntry(
               changed->index, *changed->changed_entry);
       UpdateTabNavigation(session_tab_helper->window_id(),
                           session_tab_helper->session_id(),
                           navigation);
       break;
     }
 
     case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       WebContents* web_contents =
           content::Source<content::NavigationController>(source).ptr()->
               GetWebContents();
       SessionTabHelper* session_tab_helper =
           SessionTabHelper::FromWebContents(web_contents);
       if (!session_tab_helper || web_contents->GetBrowserContext() != profile())
         return;
       int current_entry_index =
           web_contents->GetController().GetCurrentEntryIndex();
       SetSelectedNavigationIndex(
           session_tab_helper->window_id(),
           session_tab_helper->session_id(),
           current_entry_index);
-      const TabNavigation navigation =
-          TabNavigation::FromNavigationEntry(
+      const SerializedNavigationEntry navigation =
+          SerializedNavigationEntry::FromNavigationEntry(
               current_entry_index,
               *web_contents->GetController().GetEntryAtIndex(
                   current_entry_index));
       UpdateTabNavigation(
           session_tab_helper->window_id(),
           session_tab_helper->session_id(),
           navigation);
       content::Details<content::LoadCommittedDetails> changed(details);
       if (changed->type == content::NAVIGATION_TYPE_NEW_PAGE ||
         changed->type == content::NAVIGATION_TYPE_EXISTING_PAGE) {
@@ skipping 242 matching lines @@
   std::map<int, SessionTab*>::iterator i = tabs->find(tab_id);
   if (i == tabs->end()) {
     SessionTab* tab = new SessionTab();
     tab->tab_id.set_id(tab_id);
     (*tabs)[tab_id] = tab;
     return tab;
   }
   return i->second;
 }
 
-std::vector<TabNavigation>::iterator
+std::vector<SerializedNavigationEntry>::iterator
   SessionService::FindClosestNavigationWithIndex(
-    std::vector<TabNavigation>* navigations,
+    std::vector<SerializedNavigationEntry>* navigations,
     int index) {
   DCHECK(navigations);
-  for (std::vector<TabNavigation>::iterator i = navigations->begin();
-       i != navigations->end(); ++i) {
+  for (std::vector<SerializedNavigationEntry>::iterator
+           i = navigations->begin(); i != navigations->end(); ++i) {
     if (i->index() >= index)
       return i;
   }
   return navigations->end();
 }
 
 // Function used in sorting windows. Sorting is done based on window id. As
 // window ids increment for each new window, this effectively sorts by creation
 // time.
 static bool WindowOrderSortFunction(const SessionWindow* w1,
@@ skipping 45 matching lines @@
   VLOG(1) << "Tabs " << tabs->size() << ", windows " << windows->size();
   std::map<int, SessionTab*>::iterator i = tabs->begin();
   while (i != tabs->end()) {
     SessionTab* tab = i->second;
     if (tab->window_id.id() && !tab->navigations.empty()) {
       SessionWindow* window = GetWindow(tab->window_id.id(), windows);
       window->tabs.push_back(tab);
       tabs->erase(i++);
 
       // See note in SessionTab as to why we do this.
-      std::vector<TabNavigation>::iterator j =
+      std::vector<SerializedNavigationEntry>::iterator j =
           FindClosestNavigationWithIndex(&(tab->navigations),
                                          tab->current_navigation_index);
       if (j == tab->navigations.end()) {
         tab->current_navigation_index =
             static_cast<int>(tab->navigations.size() - 1);
       } else {
         tab->current_navigation_index =
             static_cast<int>(j - tab->navigations.begin());
       }
     } else {
@@ skipping 125 matching lines @@
           VLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         SessionTab* tab = GetTab(payload.id, tabs);
 
         // Update the selected navigation index.
         tab->current_navigation_index =
             std::max(-1, tab->current_navigation_index - payload.index);
 
         // And update the index of existing navigations.
-        for (std::vector<TabNavigation>::iterator i = tab->navigations.begin();
+        for (std::vector<SerializedNavigationEntry>::iterator
+                 i = tab->navigations.begin();
              i != tab->navigations.end();) {
           i->set_index(i->index() - payload.index);
           if (i->index() < 0)
             i = tab->navigations.erase(i);
           else
             ++i;
         }
         break;
       }
 
       case kCommandUpdateTabNavigation: {
-        TabNavigation navigation;
+        SerializedNavigationEntry navigation;
         SessionID::id_type tab_id;
         if (!RestoreUpdateTabNavigationCommand(
                 *command, &navigation, &tab_id)) {
           VLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         SessionTab* tab = GetTab(tab_id, tabs);
-        std::vector<TabNavigation>::iterator i =
+        std::vector<SerializedNavigationEntry>::iterator i =
             FindClosestNavigationWithIndex(&(tab->navigations),
                                            navigation.index());
         if (i != tab->navigations.end() && i->index() == navigation.index())
           *i = navigation;
         else
           tab->navigations.insert(i, navigation);
         break;
       }
 
       case kCommandSetSelectedNavigationIndex: {
@@ skipping 148 matching lines @@
         CreateSetTabUserAgentOverrideCommand(
             kCommandSetTabUserAgentOverride, session_id.id(), ua_override));
   }
 
   for (int i = min_index; i < max_index; ++i) {
     const NavigationEntry* entry = (i == pending_index) ?
         tab->GetController().GetPendingEntry() :
         tab->GetController().GetEntryAtIndex(i);
     DCHECK(entry);
     if (ShouldTrackEntry(entry->GetVirtualURL())) {
-      const TabNavigation navigation =
-          TabNavigation::FromNavigationEntry(i, *entry);
+      const SerializedNavigationEntry navigation =
+          SerializedNavigationEntry::FromNavigationEntry(i, *entry);
       commands->push_back(
           CreateUpdateTabNavigationCommand(
               kCommandUpdateTabNavigation, session_id.id(), navigation));
     }
   }
   commands->push_back(
       CreateSetSelectedNavigationIndexCommand(session_id, current_index));
 
   if (index_in_window != -1) {
     commands->push_back(
@@ skipping 429 matching lines @@
       contents->GetController().GetDefaultSessionStorageNamespace();
   session_storage_namespace->SetShouldPersist(false);
   SessionTabHelper* session_tab_helper =
       SessionTabHelper::FromWebContents(contents);
   TabClosed(session_tab_helper->window_id(),
             session_tab_helper->session_id(),
             contents->GetClosedByUserGesture());
   RecordSessionUpdateHistogramData(content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                                    &last_updated_tab_closed_time_);
 }