Do not submit: high level overview patch.

chrome/browser/sessions/tab_restore_service_helper.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/tab_restore_service_helper.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 216 matching lines @@
     Window* window = static_cast<Window*>(entry);
 
     // When restoring a window, either the entire window can be restored, or a
     // single tab within it. If the entry's ID matches the one to restore, then
     // the entire window will be restored.
     if (!restoring_tab_in_window) {
       delegate = TabRestoreServiceDelegate::Create(profile_, host_desktop_type,
                                                    window->app_name);
       for (size_t tab_i = 0; tab_i < window->tabs.size(); ++tab_i) {
         const Tab& tab = window->tabs[tab_i];
-        WebContents* restored_tab =
-            delegate->AddRestoredTab(tab.navigations, delegate->GetTabCount(),
-                                     tab.current_navigation_index,
-                                     tab.extension_app_id,
-                                     static_cast<int>(tab_i) ==
-                                         window->selected_tab_index,
-                                     tab.pinned, tab.from_last_session,
-                                     tab.session_storage_namespace,
-                                     tab.user_agent_override);
+        WebContents* restored_tab = delegate->AddRestoredTab(
+            tab.navigations,
+            delegate->GetTabCount(),
+            tab.current_navigation_index,
+            tab.extension_app_id,
+            static_cast<int>(tab_i) == window->selected_tab_index,
+            tab.pinned,
+            tab.from_last_session,
+            tab.session_storage_namespace,
+            tab.user_agent_override,
+            tab.sync_session_id);
         if (restored_tab) {
           restored_tab->GetController().LoadIfNecessary();
           RecordAppLaunch(profile_, tab);
         }
       }
       // All the window's tabs had the same former browser_id.
       if (window->tabs[0].has_browser()) {
         UpdateTabBrowserIDs(window->tabs[0].browser_id,
                             delegate->GetSessionID().id());
       }
@@ skipping 136 matching lines @@
     NavigationEntry* entry = (i == pending_index) ?
         controller->GetPendingEntry() : controller->GetEntryAtIndex(i);
     tab->navigations[i] =
         sessions::SerializedNavigationEntry::FromNavigationEntry(i, *entry);
   }
   tab->timestamp = TimeNow();
   tab->current_navigation_index = controller->GetCurrentEntryIndex();
   if (tab->current_navigation_index == -1 && entry_count > 0)
     tab->current_navigation_index = 0;
   tab->tabstrip_index = index;
+  tab->sync_session_id = tab->sync_session_id;
 
   extensions::TabHelper* extensions_tab_helper =
       extensions::TabHelper::FromWebContents(controller->GetWebContents());
   // extensions_tab_helper is NULL in some browser tests.
   if (extensions_tab_helper) {
     const extensions::Extension* extension =
         extensions_tab_helper->extension_app();
     if (extension)
       tab->extension_app_id = extension->id();
   }
@@ skipping 16 matching lines @@
     const Tab& tab,
     TabRestoreServiceDelegate* delegate,
     chrome::HostDesktopType host_desktop_type,
     WindowOpenDisposition disposition) {
   if (disposition == CURRENT_TAB && delegate) {
     delegate->ReplaceRestoredTab(tab.navigations,
                                  tab.current_navigation_index,
                                  tab.from_last_session,
                                  tab.extension_app_id,
                                  tab.session_storage_namespace,
-                                 tab.user_agent_override);
+                                 tab.user_agent_override,
+                                 tab.sync_session_id);
   } else {
     // We only respsect the tab's original browser if there's no disposition.
     if (disposition == UNKNOWN && tab.has_browser()) {
       delegate = TabRestoreServiceDelegate::FindDelegateWithID(
                      tab.browser_id, host_desktop_type);
     }
 
     int tab_index = -1;
 
     // |delegate| will be NULL in cases where one isn't already available (eg,
     // when invoked on Mac OS X with no windows open). In this case, create a
     // new browser into which we restore the tabs.
     if (delegate && disposition != NEW_WINDOW) {
       tab_index = tab.tabstrip_index;
     } else {
       delegate = TabRestoreServiceDelegate::Create(profile_, host_desktop_type,
                                                    std::string());
       if (tab.has_browser())
         UpdateTabBrowserIDs(tab.browser_id, delegate->GetSessionID().id());
     }
 
     // Place the tab at the end if the tab index is no longer valid or
     // we were passed a specific disposition.
     if (tab_index < 0 || tab_index > delegate->GetTabCount() ||
         disposition != UNKNOWN) {
       tab_index = delegate->GetTabCount();
     }
 
-    WebContents* web_contents = delegate->AddRestoredTab(
-        tab.navigations,
-        tab_index,
-        tab.current_navigation_index,
-        tab.extension_app_id,
-        disposition != NEW_BACKGROUND_TAB,
-        tab.pinned,
-        tab.from_last_session,
-        tab.session_storage_namespace,
-        tab.user_agent_override);
+    WebContents* web_contents =
+        delegate->AddRestoredTab(tab.navigations,
+                                 tab_index,
+                                 tab.current_navigation_index,
+                                 tab.extension_app_id,
+                                 disposition != NEW_BACKGROUND_TAB,
+                                 tab.pinned,
+                                 tab.from_last_session,
+                                 tab.session_storage_namespace,
+                                 tab.user_agent_override,
+                                 tab.sync_session_id);
     web_contents->GetController().LoadIfNecessary();
   }
   RecordAppLaunch(profile_, tab);
   return delegate;
 }
 
 
 bool TabRestoreServiceHelper::ValidateTab(Tab* tab) {
   if (tab->navigations.empty())
     return false;
@@ skipping 74 matching lines @@
       Tab* tab = static_cast<Tab*>(entry);
       if (tab->browser_id == old_id)
         tab->browser_id = new_id;
     }
   }
 }
 
 base::Time TabRestoreServiceHelper::TimeNow() const {
   return time_factory_ ? time_factory_->TimeNow() : base::Time::Now();
 }