Do not submit: high level overview patch.

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/sessions/session_types.h"
+#include "chrome/browser/sync/glue/synced_tab_delegate.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/startup_metric_utils.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #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;
+using browser_sync::SyncedTabDelegate;
 
 // 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;
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromBack = 5;
 static const SessionCommand::id_type kCommandUpdateTabNavigation = 6;
 static const SessionCommand::id_type kCommandSetSelectedNavigationIndex = 7;
 static const SessionCommand::id_type kCommandSetSelectedTabInIndex = 8;
 static const SessionCommand::id_type kCommandSetWindowType = 9;
 // OBSOLETE Superseded by kCommandSetWindowBounds3. Except for data migration.
 // static const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
 static const SessionCommand::id_type
     kCommandTabNavigationPathPrunedFromFront = 11;
 static const SessionCommand::id_type kCommandSetPinnedState = 12;
 static const SessionCommand::id_type kCommandSetExtensionAppID = 13;
 static const SessionCommand::id_type kCommandSetWindowBounds3 = 14;
 static const SessionCommand::id_type kCommandSetWindowAppName = 15;
 static const SessionCommand::id_type kCommandTabClosed = 16;
 static const SessionCommand::id_type kCommandWindowClosed = 17;
 static const SessionCommand::id_type kCommandSetTabUserAgentOverride = 18;
 static const SessionCommand::id_type kCommandSessionStorageAssociated = 19;
 static const SessionCommand::id_type kCommandSetActiveWindow = 20;
+static const SessionCommand::id_type kCommandSetTabSessionSyncId = 21;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
 // Various payload structures.
 struct ClosedPayload {
   SessionID::id_type id;
   int64 close_time;
@@ skipping 381 matching lines @@
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& user_agent_override) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
       kCommandSetTabUserAgentOverride, tab_id.id(), user_agent_override));
 }
 
+void SessionService::SetTabSessionSyncId(const SessionID& window_id,
+                                         const SessionID& tab_id,
+                                         const int64& sync_id) {
+  if (!ShouldTrackChangesToWindow(window_id))
+    return;
+  ScheduleCommand(CreateSetTabSessionSyncIdCommand(
+      kCommandSetTabSessionSyncId, tab_id.id(), sync_id));
+}
+
 CancelableTaskTracker::TaskId SessionService::GetLastSession(
     const SessionCallback& callback,
     CancelableTaskTracker* tracker) {
   // OnGotSessionCommands maps the SessionCommands to browser state, then run
   // the callback.
   return ScheduleGetLastSessionCommands(
       base::Bind(&SessionService::OnGotSessionCommands,
                  base::Unretained(this), callback),
       tracker);
 }
@@ skipping 18 matching lines @@
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  content::NotificationService::AllSources());
   // Wait for NOTIFICATION_BROWSER_WINDOW_READY so that is_app() is set.
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
       content::NotificationService::AllSources());
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_SESSION_SYNC_ID_GENERATED,
+                 content::NotificationService::AllSources());
 
   BrowserList::AddObserver(this);
 }
 
 bool SessionService::processed_any_commands() {
   return backend()->inited() || !pending_commands().empty();
 }
 
 bool SessionService::ShouldNewWindowStartSession() {
   // ChromeOS and OSX have different ideas of application lifetime than
@@ skipping 142 matching lines @@
       }
       if (extension_tab_helper->extension_app()) {
         SessionTabHelper* session_tab_helper =
             SessionTabHelper::FromWebContents(
                 extension_tab_helper->web_contents());
         SetTabExtensionAppID(session_tab_helper->window_id(),
                              session_tab_helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
+
+    }
+    case chrome::NOTIFICATION_SESSION_SYNC_ID_GENERATED: {
+      content::Details<const SyncedTabDelegate> tab(details);
+      SetTabSessionSyncId(
+          tab->GetWindowId(), tab->GetSessionId(), tab->GetSyncSessionId());
+      break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void SessionService::OnBrowserSetLastActive(Browser* browser) {
   if (ShouldTrackBrowser(browser))
     ScheduleCommand(CreateSetActiveWindowCommand(browser->session_id()));
@@ skipping 561 matching lines @@
       case kCommandSetActiveWindow: {
         ActiveWindowPayload payload;
         if (!command->GetPayload(&payload, sizeof(payload))) {
           VLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         *active_window_id = payload;
         break;
       }
 
+      case kCommandSetTabSessionSyncId: {
+        SessionID::id_type tab_id;
+        int64 sync_id = -1;
+        if (!RestoreSetTabSessionSyncIdCommand(*command, &tab_id, &sync_id)) {
+        }
+        GetTab(tab_id, tabs)->sync_session_id = sync_id;
+        break;
+      }
+
       default:
         VLOG(1) << "Failed reading an unknown command " << command->id();
         return true;
     }
   }
   return true;
 }
 
 void SessionService::BuildCommandsForTab(const SessionID& window_id,
                                          WebContents* tab,
@@ skipping 30 matching lines @@
             kCommandSetExtensionAppID, session_id.id(),
             extensions_tab_helper->extension_app()->id()));
   }
 
   const std::string& ua_override = tab->GetUserAgentOverride();
   if (!ua_override.empty()) {
     commands->push_back(
         CreateSetTabUserAgentOverrideCommand(
             kCommandSetTabUserAgentOverride, session_id.id(), ua_override));
   }
+  const int64 sync_id =
+      SessionTabHelper::FromWebContents(tab)->GetSessionSyncId();
+  commands->push_back(CreateSetTabSessionSyncIdCommand(
+      kCommandSetTabSessionSyncId, session_id.id(), sync_id));
 
   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 SerializedNavigationEntry navigation =
           SerializedNavigationEntry::FromNavigationEntry(i, *entry);
       commands->push_back(
@@ skipping 432 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_);
 }