Do not submit: high level overview patch.

chrome/browser/sessions/persistent_tab_restore_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/persistent_tab_restore_service.h"
 
 #include <cstring>  // memcpy
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 84 matching lines @@
 // . When the user restores an entry a command of type kCommandRestoredEntry
 //   is written.
 const SessionCommand::id_type kCommandUpdateTabNavigation = 1;
 const SessionCommand::id_type kCommandRestoredEntry = 2;
 const SessionCommand::id_type kCommandWindow = 3;
 const SessionCommand::id_type kCommandSelectedNavigationInTab = 4;
 const SessionCommand::id_type kCommandPinnedState = 5;
 const SessionCommand::id_type kCommandSetExtensionAppID = 6;
 const SessionCommand::id_type kCommandSetWindowAppName = 7;
 const SessionCommand::id_type kCommandSetTabUserAgentOverride = 8;
+const SessionCommand::id_type kCommandSetTabSessionSyncId = 9;
 
 // Number of entries (not commands) before we clobber the file and write
 // everything.
 const int kEntriesPerReset = 40;
 
 const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
@@ skipping 333 matching lines @@
         CreateSetTabExtensionAppIDCommand(kCommandSetExtensionAppID, tab.id,
                                           tab.extension_app_id));
   }
 
   if (!tab.user_agent_override.empty()) {
     ScheduleCommand(
         CreateSetTabUserAgentOverrideCommand(kCommandSetTabUserAgentOverride,
                                              tab.id, tab.user_agent_override));
   }
 
+  if (tab.sync_session_id != -1) {
+    ScheduleCommand(CreateSetTabSessionSyncIdCommand(
+        kCommandSetTabSessionSyncId, tab.id, tab.sync_session_id));
+  }
+
   // Then write the navigations.
   for (int i = first_index_to_persist, wrote_count = 0;
        i < max_index && wrote_count < 2 * max_persist_navigation_count; ++i) {
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
       ScheduleCommand(
           CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation, tab.id,
                                            navigations[i]));
     }
   }
 }
@@ skipping 260 matching lines @@
         SessionID::id_type tab_id;
         std::string user_agent_override;
         if (!RestoreSetTabUserAgentOverrideCommand(command, &tab_id,
                                                    &user_agent_override)) {
           return;
         }
         current_tab->user_agent_override.swap(user_agent_override);
         break;
       }
 
+      case kCommandSetTabSessionSyncId: {
+        if (!current_tab) {
+          // Should be in a tab when we get this.
+          return;
+        }
+        SessionID::id_type tab_id;
+        int64 sync_id;
+        if (!RestoreSetTabSessionSyncIdCommand(command, &tab_id, &sync_id)) {
+          current_tab->sync_session_id = sync_id;
+          return;
+        }
+        current_tab->sync_session_id = sync_id;
+        break;
+      }
+
       default:
         // Unknown type, usually indicates corruption of file. Ignore it.
         return;
     }
   }
 
   // If there was corruption some of the entries won't be valid.
   ValidateAndDeleteEmptyEntries(&(entries.get()));
 
   loaded_entries->swap(entries.get());
@@ skipping 37 matching lines @@
     Window* window) {
   for (size_t i = 0; i < session_window->tabs.size(); ++i) {
     if (!session_window->tabs[i]->navigations.empty()) {
       window->tabs.resize(window->tabs.size() + 1);
       Tab& tab = window->tabs.back();
       tab.pinned = session_window->tabs[i]->pinned;
       tab.navigations.swap(session_window->tabs[i]->navigations);
       tab.current_navigation_index =
           session_window->tabs[i]->current_navigation_index;
       tab.extension_app_id = session_window->tabs[i]->extension_app_id;
+      tab.sync_session_id = session_window->tabs[i]->sync_session_id;
       tab.timestamp = base::Time();
     }
   }
   if (window->tabs.empty())
     return false;
 
   window->selected_tab_index =
       std::min(session_window->selected_tab_index,
                static_cast<int>(window->tabs.size() - 1));
   window->timestamp = base::Time();
@@ skipping 167 matching lines @@
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 ProfileKeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* profile) const {
   return new PersistentTabRestoreService(static_cast<Profile*>(profile), NULL);
 }