[Extensions] Convert some ChromeSyncExtensionFunctions

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

 // Copyright 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/sessions/sessions_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 58 matching lines @@
 }
 
 // Comparator function for use with std::sort that will sort tabs in a window
 // by descending timestamp (i.e., most recent first).
 bool SortTabsByRecency(const sessions::SessionTab* t1,
                        const sessions::SessionTab* t2) {
   return t1->timestamp > t2->timestamp;
 }
 
 tabs::Tab CreateTabModelHelper(
-    Profile* profile,
     const sessions::SerializedNavigationEntry& current_navigation,
     const std::string& session_id,
     int index,
     bool pinned,
     bool active,
     const Extension* extension) {
   tabs::Tab tab_struct;
 
   const GURL& url = current_navigation.virtual_url();
   std::string title = base::UTF16ToUTF8(current_navigation.title());
@@ skipping 49 matching lines @@
 
 bool is_window_entry(const sessions::TabRestoreService::Entry& entry) {
   return entry.type == sessions::TabRestoreService::WINDOW;
 }
 
 }  // namespace
 
 tabs::Tab SessionsGetRecentlyClosedFunction::CreateTabModel(
     const sessions::TabRestoreService::Tab& tab,
     bool active) {
-  return CreateTabModelHelper(GetProfile(),
-                              tab.navigations[tab.current_navigation_index],
+  return CreateTabModelHelper(tab.navigations[tab.current_navigation_index],
                               base::IntToString(tab.id), tab.tabstrip_index,
                               tab.pinned, active, extension());
 }
 
 std::unique_ptr<windows::Window>
 SessionsGetRecentlyClosedFunction::CreateWindowModel(
     const sessions::TabRestoreService::Window& window) {
   DCHECK(!window.tabs.empty());
 
   auto tabs = base::MakeUnique<std::vector<tabs::Tab>>();
@@ skipping 20 matching lines @@
       window = CreateWindowModel(
           static_cast<const sessions::TabRestoreService::Window&>(entry));
       break;
     default:
       NOTREACHED();
   }
   return CreateSessionModelHelper(entry.timestamp.ToTimeT(), std::move(tab),
                                   std::move(window));
 }
 
-bool SessionsGetRecentlyClosedFunction::RunSync() {
+ExtensionFunction::ResponseAction SessionsGetRecentlyClosedFunction::Run() {
   std::unique_ptr<GetRecentlyClosed::Params> params(
       GetRecentlyClosed::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   int max_results = api::sessions::MAX_SESSION_RESULTS;
   if (params->filter && params->filter->max_results)
     max_results = *params->filter->max_results;
   EXTENSION_FUNCTION_VALIDATE(max_results >= 0 &&
       max_results <= api::sessions::MAX_SESSION_RESULTS);
 
   std::vector<api::sessions::Session> result;
   sessions::TabRestoreService* tab_restore_service =
-      TabRestoreServiceFactory::GetForProfile(GetProfile());
+      TabRestoreServiceFactory::GetForProfile(
+          Profile::FromBrowserContext(browser_context()));
 
   // TabRestoreServiceFactory::GetForProfile() can return NULL (i.e., when in
   // incognito mode)
   if (!tab_restore_service) {
-    DCHECK_NE(GetProfile(), GetProfile()->GetOriginalProfile())
+    DCHECK(browser_context()->IsOffTheRecord())
         << "sessions::TabRestoreService expected for normal profiles";
-    results_ = GetRecentlyClosed::Results::Create(result);
-    return true;
+    return RespondNow(ArgumentList(GetRecentlyClosed::Results::Create(result)));
   }
 
   // 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.
   for (const auto& entry : tab_restore_service->entries()) {
     result.push_back(std::move(*CreateSessionModel(*entry)));
   }
 
-  results_ = GetRecentlyClosed::Results::Create(result);
-  return true;
+  return RespondNow(ArgumentList(GetRecentlyClosed::Results::Create(result)));
 }
 
 tabs::Tab SessionsGetDevicesFunction::CreateTabModel(
     const std::string& session_tag,
     const sessions::SessionTab& tab,
     int tab_index,
     bool active) {
   std::string session_id = SessionId(session_tag, tab.tab_id.id()).ToString();
   return CreateTabModelHelper(
-      GetProfile(), tab.navigations[tab.normalized_navigation_index()],
-      session_id, tab_index, tab.pinned, active, extension());
+      tab.navigations[tab.normalized_navigation_index()], session_id, tab_index,
+      tab.pinned, active, extension());
 }
 
 std::unique_ptr<windows::Window> SessionsGetDevicesFunction::CreateWindowModel(
     const sessions::SessionWindow& window,
     const std::string& session_tag) {
   DCHECK(!window.tabs.empty());
 
   // Prune tabs that are not syncable or are NewTabPage. Then, sort the tabs
   // from most recent to least recent.
   std::vector<const sessions::SessionTab*> tabs_in_window;
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     const sessions::SessionTab* tab = window.tabs[i].get();
     if (tab->navigations.empty())
       continue;
     const sessions::SerializedNavigationEntry& current_navigation =
         tab->navigations.at(tab->normalized_navigation_index());
-    if (search::IsNTPURL(current_navigation.virtual_url(), GetProfile())) {
+    if (search::IsNTPURL(current_navigation.virtual_url(),
+                         Profile::FromBrowserContext(browser_context()))) {
       continue;
     }
     tabs_in_window.push_back(tab);
   }
   if (tabs_in_window.empty())
     return std::unique_ptr<windows::Window>();
   std::sort(tabs_in_window.begin(), tabs_in_window.end(), SortTabsByRecency);
 
   std::unique_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
   for (size_t i = 0; i < tabs_in_window.size(); ++i) {
@@ skipping 79 matching lines @@
        static_cast<int>(device_struct.sessions.size()) < max_results;
        ++it) {
     std::unique_ptr<api::sessions::Session> session_model(
         CreateSessionModel(*it->second, session->session_tag));
     if (session_model)
       device_struct.sessions.push_back(std::move(*session_model));
   }
   return device_struct;
 }
 
-bool SessionsGetDevicesFunction::RunSync() {
+ExtensionFunction::ResponseAction SessionsGetDevicesFunction::Run() {
   browser_sync::ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(GetProfile());
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(
+          Profile::FromBrowserContext(browser_context()));
   if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
     // Sync not enabled.
-    results_ =
-        GetDevices::Results::Create(std::vector<api::sessions::Device>());
-    return true;
+    return RespondNow(ArgumentList(
+        GetDevices::Results::Create(std::vector<api::sessions::Device>())));
   }
 
   sync_sessions::OpenTabsUIDelegate* open_tabs =
       service->GetOpenTabsUIDelegate();
   std::vector<const sync_sessions::SyncedSession*> sessions;
   if (!(open_tabs && open_tabs->GetAllForeignSessions(&sessions))) {
-    results_ =
-        GetDevices::Results::Create(std::vector<api::sessions::Device>());
-    return true;
+    return RespondNow(ArgumentList(
+        GetDevices::Results::Create(std::vector<api::sessions::Device>())));
   }
 
   std::unique_ptr<GetDevices::Params> params(
       GetDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
   if (params->filter && params->filter->max_results) {
     EXTENSION_FUNCTION_VALIDATE(*params->filter->max_results >= 0 &&
         *params->filter->max_results <= api::sessions::MAX_SESSION_RESULTS);
   }
 
   std::vector<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(); ++i)
     result.push_back(CreateDeviceModel(sessions[i]));
 
-  results_ = GetDevices::Results::Create(result);
-  return true;
+  return RespondNow(ArgumentList(GetDevices::Results::Create(result)));
 }
 
-void SessionsRestoreFunction::SetInvalidIdError(const std::string& invalid_id) {
-  SetError(ErrorUtils::FormatErrorMessage(kInvalidSessionIdError, invalid_id));
-}
-
-
-void SessionsRestoreFunction::SetResultRestoredTab(
+ExtensionFunction::ResponseValue SessionsRestoreFunction::GetRestoredTabResult(
     content::WebContents* contents) {
   std::unique_ptr<tabs::Tab> tab(
       ExtensionTabUtil::CreateTabObject(contents, extension()));
   std::unique_ptr<api::sessions::Session> restored_session(
       CreateSessionModelHelper(base::Time::Now().ToTimeT(), std::move(tab),
                                std::unique_ptr<windows::Window>()));
-  results_ = Restore::Results::Create(*restored_session);
+  return ArgumentList(Restore::Results::Create(*restored_session));
 }
 
-bool SessionsRestoreFunction::SetResultRestoredWindow(int window_id) {
+ExtensionFunction::ResponseValue
+SessionsRestoreFunction::GetRestoredWindowResult(int window_id) {
   WindowController* controller = NULL;
+  std::string error;
   if (!windows_util::GetWindowFromWindowID(this, window_id, 0, &controller,
-                                           &error_)) {
-    return false;
+                                           &error)) {
+    return Error(error);
   }
   std::unique_ptr<base::DictionaryValue> window_value(
       controller->CreateWindowValueWithTabs(extension()));
   std::unique_ptr<windows::Window> window(
       windows::Window::FromValue(*window_value));
-  results_ = Restore::Results::Create(*CreateSessionModelHelper(
+  return ArgumentList(Restore::Results::Create(*CreateSessionModelHelper(
       base::Time::Now().ToTimeT(), std::unique_ptr<tabs::Tab>(),
-      std::move(window)));
-  return true;
+      std::move(window))));
 }
 
-bool SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
+ExtensionFunction::ResponseValue
+SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
   sessions::TabRestoreService* tab_restore_service =
-      TabRestoreServiceFactory::GetForProfile(GetProfile());
+      TabRestoreServiceFactory::GetForProfile(
+          Profile::FromBrowserContext(browser_context()));
   const sessions::TabRestoreService::Entries& entries =
       tab_restore_service->entries();
 
-  if (entries.empty()) {
-    SetError(kNoRecentlyClosedSessionsError);
-    return false;
-  }
+  if (entries.empty())
+    return Error(kNoRecentlyClosedSessionsError);
 
   bool is_window = is_window_entry(*entries.front());
   sessions::LiveTabContext* context =
       BrowserLiveTabContext::FindContextForWebContents(
           browser->tab_strip_model()->GetActiveWebContents());
   std::vector<sessions::LiveTab*> restored_tabs =
       tab_restore_service->RestoreMostRecentEntry(context);
   DCHECK(restored_tabs.size());
 
   sessions::ContentLiveTab* first_tab =
       static_cast<sessions::ContentLiveTab*>(restored_tabs[0]);
   if (is_window) {
-    return SetResultRestoredWindow(
+    return GetRestoredWindowResult(
         ExtensionTabUtil::GetWindowIdOfTab(first_tab->web_contents()));
   }
 
-  SetResultRestoredTab(first_tab->web_contents());
-  return true;
+  return GetRestoredTabResult(first_tab->web_contents());
 }
 
-bool SessionsRestoreFunction::RestoreLocalSession(const SessionId& session_id,
-                                                  Browser* browser) {
+ExtensionFunction::ResponseValue SessionsRestoreFunction::RestoreLocalSession(
+    const SessionId& session_id,
+    Browser* browser) {
   sessions::TabRestoreService* tab_restore_service =
-      TabRestoreServiceFactory::GetForProfile(GetProfile());
+      TabRestoreServiceFactory::GetForProfile(
+          Profile::FromBrowserContext(browser_context()));
   const sessions::TabRestoreService::Entries& entries =
       tab_restore_service->entries();
 
-  if (entries.empty()) {
-    SetInvalidIdError(session_id.ToString());
-    return false;
-  }
+  if (entries.empty())
+    return Error(kInvalidSessionIdError, session_id.ToString());
 
   // Check if the recently closed list contains an entry with the provided id.
   bool is_window = false;
   for (const auto& entry : entries) {
     if (entry->id == session_id.id()) {
       // A full window is being restored only if the entry ID
       // matches the provided ID and the entry type is Window.
       is_window = is_window_entry(*entry);
       break;
     }
   }
 
   sessions::LiveTabContext* context =
       BrowserLiveTabContext::FindContextForWebContents(
           browser->tab_strip_model()->GetActiveWebContents());
   std::vector<sessions::LiveTab*> restored_tabs =
       tab_restore_service->RestoreEntryById(context, session_id.id(),
                                             WindowOpenDisposition::UNKNOWN);
   // If the ID is invalid, restored_tabs will be empty.
-  if (restored_tabs.empty()) {
-    SetInvalidIdError(session_id.ToString());
-    return false;
-  }
+  if (restored_tabs.empty())
+    return Error(kInvalidSessionIdError, session_id.ToString());
 
   sessions::ContentLiveTab* first_tab =
       static_cast<sessions::ContentLiveTab*>(restored_tabs[0]);
 
   // Retrieve the window through any of the tabs in restored_tabs.
   if (is_window) {
-    return SetResultRestoredWindow(
+    return GetRestoredWindowResult(
         ExtensionTabUtil::GetWindowIdOfTab(first_tab->web_contents()));
   }
 
-  SetResultRestoredTab(first_tab->web_contents());
-  return true;
+  return GetRestoredTabResult(first_tab->web_contents());
 }
 
-bool SessionsRestoreFunction::RestoreForeignSession(const SessionId& session_id,
-                                                    Browser* browser) {
+ExtensionFunction::ResponseValue SessionsRestoreFunction::RestoreForeignSession(
+    const SessionId& session_id,
+    Browser* browser) {
+  Profile* profile = Profile::FromBrowserContext(browser_context());
   browser_sync::ProfileSyncService* service =
-      ProfileSyncServiceFactory::GetInstance()->GetForProfile(GetProfile());
-  if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
-    SetError(kSessionSyncError);
-    return false;
-  }
+      ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
+  if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS)))
+    return Error(kSessionSyncError);
   sync_sessions::OpenTabsUIDelegate* open_tabs =
       service->GetOpenTabsUIDelegate();
-  if (!open_tabs) {
-    SetError(kSessionSyncError);
-    return false;
-  }
+  if (!open_tabs)
+    return Error(kSessionSyncError);
 
   const sessions::SessionTab* tab = NULL;
   if (open_tabs->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, WindowOpenDisposition::NEW_FOREGROUND_TAB);
-    SetResultRestoredTab(tab_contents);
-    return true;
+    return GetRestoredTabResult(tab_contents);
   }
 
   // Restoring a full window.
   std::vector<const sessions::SessionWindow*> windows;
-  if (!open_tabs->GetForeignSession(session_id.session_tag(), &windows)) {
-    SetInvalidIdError(session_id.ToString());
-    return false;
-  }
+  if (!open_tabs->GetForeignSession(session_id.session_tag(), &windows))
+    return Error(kInvalidSessionIdError, session_id.ToString());
 
   std::vector<const sessions::SessionWindow*>::const_iterator window =
       windows.begin();
   while (window != windows.end()
          && (*window)->window_id.id() != session_id.id()) {
     ++window;
   }
-  if (window == windows.end()) {
-    SetInvalidIdError(session_id.ToString());
-    return false;
-  }
+  if (window == windows.end())
+    return Error(kInvalidSessionIdError, session_id.ToString());
 
   // Only restore one window at a time.
-  std::vector<Browser*> browsers = SessionRestore::RestoreForeignSessionWindows(
-      GetProfile(), window, window + 1);
+  std::vector<Browser*> browsers =
+      SessionRestore::RestoreForeignSessionWindows(profile, 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]));
+  return GetRestoredWindowResult(ExtensionTabUtil::GetWindowId(browsers[0]));
 }
 
-bool SessionsRestoreFunction::RunSync() {
+ExtensionFunction::ResponseAction SessionsRestoreFunction::Run() {
   std::unique_ptr<Restore::Params> params(Restore::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  Browser* browser = chrome::FindBrowserWithProfile(GetProfile());
-  if (!browser) {
-    SetError(kNoBrowserToRestoreSession);
-    return false;
-  }
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  Browser* browser = chrome::FindBrowserWithProfile(profile);
+  if (!browser)
+    return RespondNow(Error(kNoBrowserToRestoreSession));
 
-  if (GetProfile() != GetProfile()->GetOriginalProfile()) {
-    SetError(kRestoreInIncognitoError);
-    return false;
-  }
+  if (profile != profile->GetOriginalProfile())
+    return RespondNow(Error(kRestoreInIncognitoError));
 
   if (!params->session_id)
-    return RestoreMostRecentlyClosed(browser);
+    return RespondNow(RestoreMostRecentlyClosed(browser));
 
   std::unique_ptr<SessionId> session_id(SessionId::Parse(*params->session_id));
-  if (!session_id) {
-    SetInvalidIdError(*params->session_id);
-    return false;
-  }
+  if (!session_id)
+    return RespondNow(Error(kInvalidSessionIdError, *params->session_id));
 
-  return session_id->IsForeign() ?
-      RestoreForeignSession(*session_id, browser)
-      : RestoreLocalSession(*session_id, browser);
+  return RespondNow(session_id->IsForeign()
+                        ? RestoreForeignSession(*session_id, browser)
+                        : RestoreLocalSession(*session_id, browser));
 }
 
 SessionsEventRouter::SessionsEventRouter(Profile* profile)
     : profile_(profile),
       tab_restore_service_(TabRestoreServiceFactory::GetForProfile(profile)) {
   // TabRestoreServiceFactory::GetForProfile() can return NULL (i.e., when in
   // incognito mode)
   if (tab_restore_service_) {
     tab_restore_service_->LoadTabsFromLastSession();
     tab_restore_service_->AddObserver(this);
@@ skipping 39 matching lines @@
   return g_factory.Pointer();
 }
 
 void SessionsAPI::OnListenerAdded(const EventListenerInfo& details) {
   sessions_event_router_.reset(
       new SessionsEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions