Sessions API - previously Session Restore API. Supports restoring currently open foreign windows an…

chrome/browser/extensions/api/sessions/sessions_api.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 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/extensions/api/session_restore/session_restore_api.h"
+#include "chrome/browser/extensions/api/sessions/sessions_api.h"
 
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
+#include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
+#include "chrome/browser/extensions/api/sessions/session_id.h"
+#include "chrome/browser/extensions/api/tabs/windows_util.h"
+#include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/extensions/window_controller.h"
+#include "chrome/browser/extensions/window_controller_list.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/tab_restore_service_delegate.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/sync/glue/session_model_associator.h"
 #include "chrome/browser/sync/glue/synced_session.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/pref_names.cc"
 #include "content/public/browser/web_contents.h"
+#include "extensions/common/error_utils.h"
+#include "net/base/net_util.h"
 #include "ui/base/layout.h"
 
-
-namespace {
-
-const unsigned int kMaxRecentlyClosedSessionResults = 25;
-const char kRecentlyClosedListEmpty[] =
-    "There are no recently closed sessions.";
-const char kInvalidSessionId[] = "Invalid session id.";
-const char kNoBrowserToRestoreSession[] =
-    "There are no browser windows to restore the session.";
-
-}  // namespace
-
 namespace extensions {
 
-namespace GetRecentlyClosed = api::session_restore::GetRecentlyClosed;
-namespace Restore = api::session_restore::Restore;
+namespace GetRecentlyClosed = api::sessions::GetRecentlyClosed;
+namespace GetDevices = api::sessions::GetDevices;
+namespace Restore = api::sessions::Restore;
 namespace tabs = api::tabs;
 namespace windows = api::windows;
-namespace session_restore = api::session_restore;
 
-scoped_ptr<tabs::Tab> SessionRestoreGetRecentlyClosedFunction::CreateTabModel(
-    const TabRestoreService::Tab& tab, int selected_index) {
+const int kMaxRecentlyClosedSessionResults = 25;

[not at google - send to devlin, 2013/08/19 19:34:40]

I just remembered something else. You can define constants in the schema files,
which is great because (a) it actually gets documented, (b) the documentation
will always be up to date with reality, and (c) the extensions can access that
data as well (e.g. via chrome.sessions.MAX_RECENTLY_CLOSED_SESSION_RESULTS.

OTOH you really need to make sure it has a good name.

Example:

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/common/exte...

and use:

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...

P.S. hoping 25 isn't too few. Let's see.

+const int kMaxDeviceResults = 10;

[not at google - send to devlin, 2013/08/15 20:16:24]

See comment in last patchset; I don't think having a max number of devices is
very useful, but limiting the number of sessions per devices would be.

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+const char kNoRecentlyClosedSessionsError[] =
+    "There are no recently closed sessions.";
+const char kInvalidSessionIdError[] = "Invalid session id: \"*\".";
+const char kNoBrowserToRestoreSession[] =
+    "There are no browser windows to restore the session.";
+const char kSessionSyncError[] = "Synced sessions are not available.";
+
+// Comparator function for use with std::sort that will sort sessions by
+// descending modified_time (i.e., most recent first).
+bool SortSessionsByRecency(const browser_sync::SyncedSession* s1,
+                           const browser_sync::SyncedSession* s2) {
+  return s1->modified_time > s2->modified_time;
+}
+
+scoped_ptr<tabs::Tab> CreateTabModelHelper(
+    Profile* profile,
+    const sessions::SerializedNavigationEntry& current_navigation,
+    const std::string& session_id,
+    int index,
+    bool pinned,
+    int selected_index,
+    const Extension* extension) {
   scoped_ptr<tabs::Tab> tab_struct(new tabs::Tab);
-  const sessions::SerializedNavigationEntry& current_navigation =
-      tab.navigations[tab.current_navigation_index];
+
   GURL gurl = current_navigation.virtual_url();
   std::string title = UTF16ToUTF8(current_navigation.title());
 
+  tab_struct->session_id.reset(new std::string(session_id));
   tab_struct->url.reset(new std::string(gurl.spec()));
-  tab_struct->title.reset(new std::string(title.empty() ? gurl.spec() : title));
-  tab_struct->index = tab.tabstrip_index;
-  tab_struct->pinned = tab.pinned;
-  tab_struct->id = tab.id;
-  tab_struct->window_id = tab.browser_id;
-  tab_struct->index = tab.tabstrip_index;
-  tab_struct->pinned = tab.pinned;
-  tab_struct->selected = tab.tabstrip_index == selected_index;
+  if (!title.empty()) {
+    tab_struct->title.reset(new std::string(title));
+  } else {
+    const std::string languages(

[not at google - send to devlin, 2013/08/15 20:16:24]

general nit: prefer assign syntax = over constructor syntax for situations like
these.

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+        profile->GetPrefs()->GetString(prefs::kAcceptLanguages));
+    tab_struct->title.reset(new std::string(UTF16ToUTF8(
+        net::FormatUrl(gurl, languages, net::kFormatUrlOmitAll,
+                       net::UnescapeRule::NORMAL, NULL, NULL, NULL))));

[not at google - send to devlin, 2013/08/15 20:16:24]

I think you only need the first 2 arguments.

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+  }
+  tab_struct->index = index;
+  tab_struct->pinned = pinned;
+  tab_struct->selected = index == selected_index;
   tab_struct->active = false;
   tab_struct->highlighted = false;
   tab_struct->incognito = false;
-  ExtensionTabUtil::ScrubTabForExtension(GetExtension(),
-                                         tab_struct.get());
+  ExtensionTabUtil::ScrubTabForExtension(extension, tab_struct.get());
   return tab_struct.Pass();
 }
 
+scoped_ptr<windows::Window> CreateWindowModelHelper(
+    scoped_ptr<std::vector<linked_ptr<tabs::Tab> > > tabs,
+    const std::string& session_id,
+    const windows::Window::Type& type,
+    const windows::Window::State& state) {
+  scoped_ptr<windows::Window> window_struct(new windows::Window);
+  window_struct->tabs.reset(tabs.release());

[not at google - send to devlin, 2013/08/15 20:16:24]

should be able to do window_struct->tabs = tabs.Pass() here.

ditto the few places below here.

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+  window_struct->session_id.reset(new std::string(session_id));
+  window_struct->incognito = false;
+  window_struct->always_on_top = false;
+  window_struct->focused = false;
+  window_struct->type = type;
+  window_struct->state = state;
+  return window_struct.Pass();
+}
+
+scoped_ptr<api::sessions::Session> CreateSessionModelHelper(
+    int last_modified,
+    scoped_ptr<tabs::Tab> tab,
+    scoped_ptr<windows::Window> window) {
+  scoped_ptr<api::sessions::Session> session_struct(new api::sessions::Session);
+  session_struct->last_modified = last_modified;
+  if (tab)
+    session_struct->tab.reset(tab.release());
+  else if (window)
+    session_struct->window.reset(window.release());
+  else
+    NOTREACHED();
+  return session_struct.Pass();
+}
+
+bool is_tab_entry(const TabRestoreService::Entry* entry) {
+  return entry->type == TabRestoreService::TAB;
+}
+
+bool is_window_entry(const TabRestoreService::Entry* entry) {
+  return entry->type == TabRestoreService::WINDOW;
+}
+
+scoped_ptr<tabs::Tab> SessionsGetRecentlyClosedFunction::CreateTabModel(
+    const TabRestoreService::Tab& tab, int session_id, int selected_index) {
+  return CreateTabModelHelper(profile(),
+                              tab.navigations[tab.current_navigation_index],
+                              base::IntToString(session_id),
+                              tab.tabstrip_index,
+                              tab.pinned,
+                              selected_index,
+                              GetExtension());
+}
+
 scoped_ptr<windows::Window>
-    SessionRestoreGetRecentlyClosedFunction::CreateWindowModel(
-        const TabRestoreService::Window& window) {
-  scoped_ptr<windows::Window> window_struct(new windows::Window);
+    SessionsGetRecentlyClosedFunction::CreateWindowModel(
+        const TabRestoreService::Window& window,
+        int session_id) {
   DCHECK(!window.tabs.empty());
 
   scoped_ptr<std::vector<linked_ptr<tabs::Tab> > > tabs(
       new std::vector<linked_ptr<tabs::Tab> >);
   for (size_t i = 0; i < window.tabs.size(); ++i) {
-    tabs->push_back(make_linked_ptr(CreateTabModel(window.tabs[i],
-        window.selected_tab_index).release()));
+    tabs->push_back(make_linked_ptr(
+        CreateTabModel(window.tabs[i], window.tabs[i].id,
+                       window.selected_tab_index).release()));
   }
-  window_struct->tabs.reset(tabs.release());
-  window_struct->incognito = false;
-  window_struct->always_on_top = false;
-  window_struct->focused = false;
-  window_struct->type = windows::Window::TYPE_NORMAL;
-  window_struct->state = windows::Window::STATE_NORMAL;
-  return window_struct.Pass();
+
+  return CreateWindowModelHelper(tabs.Pass(),
+                                 base::IntToString(session_id),
+                                 windows::Window::TYPE_NORMAL,
+                                 windows::Window::STATE_NORMAL);
 }
 
-scoped_ptr<session_restore::ClosedEntry>
-    SessionRestoreGetRecentlyClosedFunction::CreateEntryModel(
+scoped_ptr<api::sessions::Session>
+    SessionsGetRecentlyClosedFunction::CreateSessionModel(
         const TabRestoreService::Entry* entry) {
-  scoped_ptr<session_restore::ClosedEntry> entry_struct(
-      new session_restore::ClosedEntry);
+  scoped_ptr<tabs::Tab> tab;
+  scoped_ptr<windows::Window> window;
   switch (entry->type) {
     case TabRestoreService::TAB:
-      entry_struct->tab.reset(CreateTabModel(
-          *static_cast<const TabRestoreService::Tab*>(entry), -1).release());
+      tab = CreateTabModel(
+          *static_cast<const TabRestoreService::Tab*>(entry), entry->id, -1);
       break;
     case TabRestoreService::WINDOW:
-      entry_struct->window.reset(CreateWindowModel(
-          *static_cast<const TabRestoreService::Window*>(entry)).release());
+      window = CreateWindowModel(
+        *static_cast<const TabRestoreService::Window*>(entry), entry->id);
       break;
     default:
       NOTREACHED();
   }
-  entry_struct->timestamp = entry->timestamp.ToTimeT();
-  entry_struct->id = entry->id;
-  return entry_struct.Pass();
+  return CreateSessionModelHelper(entry->timestamp.ToTimeT(),
+                                  tab.Pass(),
+                                  window.Pass());
 }
 
-bool SessionRestoreGetRecentlyClosedFunction::RunImpl() {
+bool SessionsGetRecentlyClosedFunction::RunImpl() {
   scoped_ptr<GetRecentlyClosed::Params> params(
       GetRecentlyClosed::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-  unsigned int max_results = kMaxRecentlyClosedSessionResults;
+  int max_results = kMaxRecentlyClosedSessionResults;
   if (params->options && params->options->max_results)
     max_results = *params->options->max_results;
   EXTENSION_FUNCTION_VALIDATE(max_results >= 0 &&
                               max_results <= kMaxRecentlyClosedSessionResults);
 
-  std::vector<linked_ptr<session_restore::ClosedEntry> > result;
+  std::vector<linked_ptr<api::sessions::Session> > result;
   TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(profile());
   DCHECK(tab_restore_service);
 
   // List of entries. They are ordered from most to least recent.
   // We prune the list to contain max 25 entries at any time and removes
   // uninteresting entries.
   TabRestoreService::Entries entries = tab_restore_service->entries();
   for (TabRestoreService::Entries::const_iterator it = entries.begin();
-       it != entries.end() && result.size() < max_results; ++it) {
+       it != entries.end() && static_cast<int>(result.size()) < max_results;
+       ++it) {
     TabRestoreService::Entry* entry = *it;
     if (!params->options || params->options->entry_type ==
         GetRecentlyClosed::Params::Options::ENTRY_TYPE_NONE) {
       // Include both tabs and windows if type is not defined.
-      result.push_back(make_linked_ptr(CreateEntryModel(entry).release()));
+      result.push_back(make_linked_ptr(CreateSessionModel(entry).release()));
     } else if (
         (params->options->entry_type ==
             GetRecentlyClosed::Params::Options::ENTRY_TYPE_TAB &&
-                entry->type == TabRestoreService::TAB) ||
+                is_tab_entry(entry)) ||
         (params->options->entry_type ==
             GetRecentlyClosed::Params::Options::ENTRY_TYPE_WINDOW &&
-                entry->type == TabRestoreService::WINDOW)) {
-      result.push_back(make_linked_ptr(CreateEntryModel(entry).release()));
+                is_window_entry(entry))) {
+      result.push_back(make_linked_ptr(CreateSessionModel(entry).release()));
     }
   }
 
   results_ = GetRecentlyClosed::Results::Create(result);
   return true;
 }
 
-bool SessionRestoreRestoreFunction::RunImpl() {
+scoped_ptr<tabs::Tab> SessionsGetDevicesFunction::CreateTabModel(
+    const std::string& session_tag,
+    const SessionTab& tab,
+    int tab_index,
+    int selected_index) {
+  std::string session_id = SessionId(session_tag, tab.tab_id.id()).ToString();
+  return CreateTabModelHelper(profile(),
+                              tab.navigations[tab.current_navigation_index],
+                              session_id,
+                              tab_index,
+                              tab.pinned,
+                              selected_index,
+                              GetExtension());
+}
+
+scoped_ptr<windows::Window> SessionsGetDevicesFunction::CreateWindowModel(
+        const SessionWindow& window, const std::string& session_tag) {
+  DCHECK(!window.tabs.empty());
+
+  scoped_ptr<std::vector<linked_ptr<tabs::Tab> > > tabs(
+      new std::vector<linked_ptr<tabs::Tab> >);
+  for (size_t i = 0; i < window.tabs.size(); ++i) {
+    tabs->push_back(make_linked_ptr(
+        CreateTabModel(session_tag, *window.tabs[i], i,
+                       window.selected_tab_index).release()));
+  }
+
+  std::string session_id =
+      SessionId(session_tag, window.window_id.id()).ToString();
+
+  windows::Window::Type type = windows::Window::TYPE_NONE;
+  switch (window.type) {
+    case Browser::TYPE_TABBED:
+      type = windows::Window::TYPE_NORMAL;
+      break;
+    case Browser::TYPE_POPUP:
+      type = windows::Window::TYPE_POPUP;
+      break;
+  }
+
+  windows::Window::State state = windows::Window::STATE_NONE;
+  switch (window.show_state) {
+    case ui::SHOW_STATE_NORMAL:
+      state = windows::Window::STATE_NORMAL;
+      break;
+    case ui::SHOW_STATE_MINIMIZED:
+      state = windows::Window::STATE_MINIMIZED;
+      break;
+    case ui::SHOW_STATE_MAXIMIZED:
+      state = windows::Window::STATE_MAXIMIZED;
+      break;
+    case ui::SHOW_STATE_FULLSCREEN:
+      state = windows::Window::STATE_FULLSCREEN;
+      break;
+    default:
+      break;

[not at google - send to devlin, 2013/08/15 20:16:24]

 but no need for the default: case.

[Kristen Dwan, 2013/08/16 22:03:06]

there are 4 cases not dealt with here that we just consider state::none..
(default, inactive, detached, and end) that are causing compiler errors w/o
default.

[not at google - send to devlin, 2013/08/19 19:34:40]

That's ok, just be explicit about those 4 arguments. Fall-through cases etc.

[Kristen Dwan, 2013/08/19 21:35:05]

Done.

+  }
+
+  scoped_ptr<windows::Window> window_struct(
+      CreateWindowModelHelper(tabs.Pass(), session_id, type, state));
+  // TODO(dwankri): Dig deeper to resolve bounds not being optional, so closed
+  // windows in GetRecentlyClosed can have set values in Window helper.
+  window_struct->left.reset(new int(window.bounds.x()));
+  window_struct->top.reset(new int(window.bounds.y()));
+  window_struct->width.reset(new int(window.bounds.width()));
+  window_struct->height.reset(new int(window.bounds.height()));
+
+  return window_struct.Pass();
+}
+
+scoped_ptr<api::sessions::Session>
+SessionsGetDevicesFunction::CreateSessionModel(
+    const SessionWindow& window, const std::string& session_tag) {
+  return CreateSessionModelHelper(window.timestamp.ToTimeT(),
+                                  scoped_ptr<tabs::Tab>(),
+                                  CreateWindowModel(window, session_tag));
+}
+
+scoped_ptr<api::sessions::Device> SessionsGetDevicesFunction::CreateDeviceModel(
+    const browser_sync::SyncedSession* session) {
+  scoped_ptr<api::sessions::Device> device_struct(new api::sessions::Device);
+  device_struct->info = session->session_name;
+
+  for (browser_sync::SyncedSession::SyncedWindowMap::const_iterator it =
+       session->windows.begin(); it != session->windows.end(); ++it) {
+    device_struct->sessions.push_back(make_linked_ptr(CreateSessionModel(
+        *it->second, session->session_tag).release()));
+  }
+  return device_struct.Pass();
+}
+
+bool SessionsGetDevicesFunction::RunImpl() {
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile());
+  if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
+    // Sync not enabled.
+    results_ = GetDevices::Results::Create(
+        std::vector<linked_ptr<api::sessions::Device> >());
+    return true;
+  }
+
+  browser_sync::SessionModelAssociator* associator =
+      service->GetSessionModelAssociator();
+  std::vector<const browser_sync::SyncedSession*> sessions;
+  if (!(associator && associator->GetAllForeignSessions(&sessions))) {
+    results_ = GetDevices::Results::Create(
+        std::vector<linked_ptr<api::sessions::Device> >());
+    return true;
+  }
+
+  int max_results = kMaxDeviceResults;
+  scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  if (params->options && params->options->max_results)
+    max_results = *params->options->max_results.get();
+  EXTENSION_FUNCTION_VALIDATE(max_results >= 0 &&
+                              max_results <= kMaxDeviceResults);
+
+  std::vector<linked_ptr<api::sessions::Device> > result;
+  // Sort sessions from most recent to least recent.
+  std::sort(sessions.begin(), sessions.end(), SortSessionsByRecency);
+  for (size_t i = 0; i < sessions.size() &&
+      static_cast<int>(result.size()) < max_results; ++i) {
+    result.push_back(make_linked_ptr(CreateDeviceModel(sessions[i]).release()));
+  }
+
+  results_ = GetDevices::Results::Create(result);
+  return true;
+}
+
+void SessionsRestoreFunction::SetInvalidIdError(const std::string& invalid_id) {
+  SetError(ErrorUtils::FormatErrorMessage(kInvalidSessionIdError, invalid_id));
+}
+
+
+void SessionsRestoreFunction::SetResultRestoredTab(
+    const content::WebContents* contents) {
+  scoped_ptr<tabs::Tab> tab(tabs::Tab::FromValue(
+      *ExtensionTabUtil::CreateTabValue(contents, GetExtension())));
+  results_ = Restore::Results::Create(*CreateSessionModelHelper(

[not at google - send to devlin, 2013/08/15 20:16:24]

I think this is dereferencing a just-released pointer, if I'm organising the
parentheses correctly. *CreateSessionModelHelper(...).release(). You'll need to
save a reference to the scoped_ptr beforehand.

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+      base::Time::Now().ToTimeT(),
+      tab.Pass(),
+      scoped_ptr<windows::Window>()).release());
+}
+
+bool SessionsRestoreFunction::SetResultRestoredWindow(int window_id) {
+    WindowController* controller = NULL;
+  if (!windows_util::GetWindowFromWindowID(this, window_id, &controller)) {
+    // error_ is set by GetWindowFromWindowId function call.
+    return false;
+  }
+  scoped_ptr<windows::Window> window(windows::Window::FromValue(
+      *controller->CreateWindowValueWithTabs(GetExtension())));
+  results_ = Restore::Results::Create(*CreateSessionModelHelper(
+      base::Time::Now().ToTimeT(),
+      scoped_ptr<tabs::Tab>(),
+      window.Pass()).get());
+  return true;
+}
+
+bool SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
+  TabRestoreService* tab_restore_service =
+      TabRestoreServiceFactory::GetForProfile(profile());
+  chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
+  TabRestoreService::Entries entries = tab_restore_service->entries();
+
+  if (entries.empty()) {
+    SetError(kNoRecentlyClosedSessionsError);
+    return false;
+  }
+
+  bool is_window = is_window_entry(entries.front());
+  TabRestoreServiceDelegate* delegate =
+      TabRestoreServiceDelegate::FindDelegateForWebContents(
+          browser->tab_strip_model()->GetActiveWebContents());
+  std::vector<content::WebContents*> contents =
+      tab_restore_service->RestoreMostRecentEntry(delegate, host_desktop_type);
+  DCHECK(contents.size());
+
+  if (is_window) {
+    return SetResultRestoredWindow(
+        ExtensionTabUtil::GetWindowIdOfTab(contents[0]));
+  }
+
+  SetResultRestoredTab(contents[0]);
+  return true;
+}
+
+bool SessionsRestoreFunction::RestoreLocalSession(const SessionId* session_id,

[not at google - send to devlin, 2013/08/15 20:16:24]

just pass in a const ref

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+                                                  Browser* browser) {
+  TabRestoreService* tab_restore_service =
+      TabRestoreServiceFactory::GetForProfile(profile());
+  chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
+  TabRestoreService::Entries entries = tab_restore_service->entries();
+
+  if (entries.empty()) {
+    SetInvalidIdError(session_id->ToString());
+    return false;
+  }
+
+  // Check if the recently closed list contains an entry with the provided id.
+  bool is_window = false;
+  for (TabRestoreService::Entries::iterator it = entries.begin();
+       it != entries.end(); ++it) {
+    if ((*it)->id == session_id->id()) {
+      // The only time a full window is being restored is if the entry ID
+      // matches the provided ID and the entry type is Window.
+      is_window = is_window_entry(*it);
+      break;
+    }
+  }
+
+  TabRestoreServiceDelegate* delegate =
+      TabRestoreServiceDelegate::FindDelegateForWebContents(
+          browser->tab_strip_model()->GetActiveWebContents());
+  std::vector<content::WebContents*> contents =
+      tab_restore_service->RestoreEntryById(delegate,
+                                            session_id->id(),
+                                            host_desktop_type,
+                                            UNKNOWN);
+  // If the ID is invalid, contents will be empty.
+  if (!contents.size()) {
+    SetInvalidIdError(session_id->ToString());
+    return false;
+  }
+
+  // Retrieve the window through any of the tabs in contents.
+  if (is_window) {
+    return SetResultRestoredWindow(
+        ExtensionTabUtil::GetWindowIdOfTab(contents[0]));
+  }
+
+  SetResultRestoredTab(contents[0]);
+  return true;
+}
+
+bool SessionsRestoreFunction::RestoreForeignSession(const SessionId* session_id,

[not at google - send to devlin, 2013/08/15 20:16:24]

const ref

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+                                                    Browser* browser) {
+  ProfileSyncService* service =
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile());
+  if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
+    SetError(kSessionSyncError);
+    return false;
+  }
+  browser_sync::SessionModelAssociator* associator =
+      service->GetSessionModelAssociator();
+  if (!associator) {
+    SetError(kSessionSyncError);
+    return false;
+  }
+
+  const SessionTab* tab = NULL;
+  if (associator->GetForeignTab(session_id->session_tag(),
+                                session_id->id(),
+                                &tab)) {
+    TabStripModel* tab_strip = browser->tab_strip_model();
+    content::WebContents* contents = tab_strip->GetActiveWebContents();
+
+    content::WebContents* tab_contents =
+        SessionRestore::RestoreForeignSessionTab(contents, *tab,
+                                                 NEW_FOREGROUND_TAB);
+    SetResultRestoredTab(tab_contents);
+    return true;
+  }
+
+  // Restoring a full window.
+  std::vector<const SessionWindow*> windows;
+  if (!associator->GetForeignSession(session_id->session_tag(), &windows)) {
+    SetInvalidIdError(session_id->ToString());
+    return false;
+  }
+
+  std::vector<const SessionWindow*>::const_iterator window = windows.begin();
+  while (window != windows.end()
+      && (*window)->window_id.id() != session_id->id()) {

[not at google - send to devlin, 2013/08/15 20:16:24]

nitty align condition vertically

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+    ++window;
+  }
+  if (window == windows.end()) {
+    SetInvalidIdError(session_id->ToString());
+    return false;
+  }
+
+  chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
+  // Only restore one window at a time.
+  std::vector<Browser*> browsers =
+      SessionRestore::RestoreForeignSessionWindows(profile(), host_desktop_type,
+                                                   window, window + 1);
+  // Will always create one browser because we only restore one window per call.
+  DCHECK_EQ(1u, browsers.size());
+  return SetResultRestoredWindow(ExtensionTabUtil::GetWindowId(browsers[0]));
+}
+
+bool SessionsRestoreFunction::RunImpl() {
   scoped_ptr<Restore::Params> params(Restore::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Browser* browser =
       chrome::FindBrowserWithProfile(profile(),
                                      chrome::HOST_DESKTOP_TYPE_NATIVE);
   if (!browser) {
-    error_ = kNoBrowserToRestoreSession;
-    return false;
-  }
-
-  TabRestoreService* tab_restore_service =
-      TabRestoreServiceFactory::GetForProfile(profile());
-  TabRestoreServiceDelegate* delegate =
-      TabRestoreServiceDelegate::FindDelegateForWebContents(
-          browser->tab_strip_model()->GetActiveWebContents());
-  DCHECK(delegate);
-  chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
-  TabRestoreService::Entries entries = tab_restore_service->entries();
-
-  if (entries.empty()) {
-    error_ = kRecentlyClosedListEmpty;
-    return false;
-  }
-
-  if (!params->id) {
-    tab_restore_service->RestoreMostRecentEntry(delegate, host_desktop_type);
-    return true;
-  }
-
-  // Check if the recently closed list contains an entry with the provided id.
-  bool is_valid_id = false;
-  for (TabRestoreService::Entries::iterator it = entries.begin();
-       it != entries.end(); ++it) {
-    if ((*it)->id == *params->id) {
-      is_valid_id = true;
-      break;
-    }
-
-    // For Window entries, see if the ID matches a tab. If so, report true for
-    // the window as the Entry.
-    if ((*it)->type == TabRestoreService::WINDOW) {
-      std::vector<TabRestoreService::Tab>& tabs =
-          static_cast<TabRestoreService::Window*>(*it)->tabs;
-      for (std::vector<TabRestoreService::Tab>::iterator tab_it = tabs.begin();
-           tab_it != tabs.end(); ++tab_it) {
-        if ((*tab_it).id == *params->id) {
-          is_valid_id = true;
-          break;
-        }
-      }
-    }
-  }
-
-  if (!is_valid_id) {
-    error_ = kInvalidSessionId;
-    return false;
-  }
-
-  tab_restore_service->RestoreEntryById(delegate, *params->id,
-      host_desktop_type, UNKNOWN);
-  return true;
-}
-
-SessionRestoreAPI::SessionRestoreAPI(Profile* profile) {
-}
-
-SessionRestoreAPI::~SessionRestoreAPI() {
-}
-
-static base::LazyInstance<ProfileKeyedAPIFactory<SessionRestoreAPI> >
+    SetError(kNoBrowserToRestoreSession);
+    return false;
+  }
+
+  if (!params->session_id)
+    return RestoreMostRecentlyClosed(browser);
+
+  scoped_ptr<SessionId> session_id(SessionId::Parse(*params->session_id));
+  if (!session_id) {
+    SetInvalidIdError(*params->session_id);
+    return false;
+  }
+
+  if (session_id->IsForeign()) {
+    return RestoreForeignSession(session_id.get(), browser);
+  }
+  return RestoreLocalSession(session_id.get(), browser);

[not at google - send to devlin, 2013/08/15 20:16:24]

ternary if you feel like it

[Kristen Dwan, 2013/08/16 22:03:06]

Done.

+}
+
+SessionsAPI::SessionsAPI(Profile* profile) {
+}
+
+SessionsAPI::~SessionsAPI() {
+}
+
+static base::LazyInstance<ProfileKeyedAPIFactory<SessionsAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
-ProfileKeyedAPIFactory<SessionRestoreAPI>*
-    SessionRestoreAPI::GetFactoryInstance() {
+ProfileKeyedAPIFactory<SessionsAPI>*
+    SessionsAPI::GetFactoryInstance() {
   return &g_factory.Get();
 }
 
 }  // namespace extensions