Make TabRestoreService::Entry noncopyable and fix up surrounding code.

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 26 matching lines @@
 #include "components/url_formatter/url_formatter.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/error_utils.h"
 #include "ui/base/layout.h"
 
 namespace extensions {
 
+namespace {
+
 namespace GetRecentlyClosed = api::sessions::GetRecentlyClosed;
 namespace GetDevices = api::sessions::GetDevices;
 namespace Restore = api::sessions::Restore;
 namespace tabs = api::tabs;
 namespace windows = api::windows;
 
 const char kNoRecentlyClosedSessionsError[] =
     "There are no recently closed sessions.";
 const char kInvalidSessionIdError[] = "Invalid session id: \"*\".";
 const char kNoBrowserToRestoreSession[] =
@@ skipping 15 matching lines @@
                        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,
-    int selected_index,
+    bool active,
     const Extension* extension) {
   tabs::Tab tab_struct;
 
   const GURL& url = current_navigation.virtual_url();
   std::string title = base::UTF16ToUTF8(current_navigation.title());
 
   tab_struct.session_id.reset(new std::string(session_id));
   tab_struct.url.reset(new std::string(url.spec()));
   tab_struct.fav_icon_url.reset(
       new std::string(current_navigation.favicon_url().spec()));
   if (!title.empty()) {
     tab_struct.title.reset(new std::string(title));
   } else {
     tab_struct.title.reset(new std::string(
         base::UTF16ToUTF8(url_formatter::FormatUrl(url))));
   }
   tab_struct.index = index;
   tab_struct.pinned = pinned;
-  // Note: |selected_index| from the sync sessions model is what we call
-  // "active" in extensions terminology.  "selected" is deprecated because it's
-  // not clear whether it means "active" (user can see) or "highlighted" (user
-  // has highlighted, since you can select tabs without bringing them into the
-  // foreground).
-  tab_struct.active = index == selected_index;
+  tab_struct.active = active;
   ExtensionTabUtil::ScrubTabForExtension(extension, nullptr, &tab_struct);
   return tab_struct;
 }
 
 std::unique_ptr<windows::Window> CreateWindowModelHelper(
     std::unique_ptr<std::vector<tabs::Tab>> tabs,
     const std::string& session_id,
     const windows::WindowType& type,
     const windows::WindowState& state) {
   std::unique_ptr<windows::Window> window_struct(new windows::Window);
@@ skipping 16 matching lines @@
   session_struct->last_modified = last_modified;
   if (tab)
     session_struct->tab = std::move(tab);
   else if (window)
     session_struct->window = std::move(window);
   else
     NOTREACHED();
   return session_struct;
 }
 
-bool is_tab_entry(const sessions::TabRestoreService::Entry* entry) {
-  return entry->type == sessions::TabRestoreService::TAB;
+bool is_window_entry(const sessions::TabRestoreService::Entry& entry) {
+  return entry.type == sessions::TabRestoreService::WINDOW;
 }
 
-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,
-    int session_id,
-    int selected_index) {
+    bool active) {
   return CreateTabModelHelper(GetProfile(),
                               tab.navigations[tab.current_navigation_index],
-                              base::IntToString(session_id),
-                              tab.tabstrip_index,
-                              tab.pinned,
-                              selected_index,
-                              extension());
+                              base::IntToString(tab.id), tab.tabstrip_index,
+                              tab.pinned, active, extension());
 }
 
 std::unique_ptr<windows::Window>
 SessionsGetRecentlyClosedFunction::CreateWindowModel(
-    const sessions::TabRestoreService::Window& window,
-    int session_id) {
+    const sessions::TabRestoreService::Window& window) {
   DCHECK(!window.tabs.empty());
 
-  std::unique_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
-  for (size_t i = 0; i < window.tabs.size(); ++i) {
-    tabs->push_back(CreateTabModel(window.tabs[i], window.tabs[i].id,
-                                   window.selected_tab_index));
-  }
+  auto tabs = base::MakeUnique<std::vector<tabs::Tab>>();
+  for (const auto& tab : window.tabs)
+    tabs->push_back(
+        CreateTabModel(*tab, tab->tabstrip_index == window.selected_tab_index));
 
-  return CreateWindowModelHelper(std::move(tabs), base::IntToString(session_id),
+  return CreateWindowModelHelper(std::move(tabs), base::IntToString(window.id),
                                  windows::WINDOW_TYPE_NORMAL,
                                  windows::WINDOW_STATE_NORMAL);
 }
 
 std::unique_ptr<api::sessions::Session>
 SessionsGetRecentlyClosedFunction::CreateSessionModel(
-    const sessions::TabRestoreService::Entry* entry) {
+    const sessions::TabRestoreService::Entry& entry) {
   std::unique_ptr<tabs::Tab> tab;
   std::unique_ptr<windows::Window> window;
-  switch (entry->type) {
+  switch (entry.type) {
     case sessions::TabRestoreService::TAB:
       tab.reset(new tabs::Tab(CreateTabModel(
-          *static_cast<const sessions::TabRestoreService::Tab*>(entry),
-          entry->id, -1)));
+          static_cast<const sessions::TabRestoreService::Tab&>(entry), false)));
       break;
     case sessions::TabRestoreService::WINDOW:
       window = CreateWindowModel(
-          *static_cast<const sessions::TabRestoreService::Window*>(entry),
-          entry->id);
+          static_cast<const sessions::TabRestoreService::Window&>(entry));
       break;
     default:
       NOTREACHED();
   }
-  return CreateSessionModelHelper(entry->timestamp.ToTimeT(), std::move(tab),
+  return CreateSessionModelHelper(entry.timestamp.ToTimeT(), std::move(tab),
                                   std::move(window));
 }
 
 bool SessionsGetRecentlyClosedFunction::RunSync() {
   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() can return NULL (i.e., when in
   // incognito mode)
   if (!tab_restore_service) {
     DCHECK_NE(GetProfile(), GetProfile()->GetOriginalProfile())
         << "sessions::TabRestoreService expected for normal profiles";
     results_ = GetRecentlyClosed::Results::Create(result);
     return true;
   }
 
   // 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 sessions::TabRestoreService::Entry* entry :
-       tab_restore_service->entries()) {
-    result.push_back(std::move(*CreateSessionModel(entry)));
+  for (const auto& entry : tab_restore_service->entries()) {
+    result.push_back(std::move(*CreateSessionModel(*entry)));
   }
 
   results_ = GetRecentlyClosed::Results::Create(result);
   return true;
 }
 
 tabs::Tab SessionsGetDevicesFunction::CreateTabModel(
     const std::string& session_tag,
     const sessions::SessionTab& tab,
     int tab_index,
-    int selected_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,
-      selected_index,
-      extension());
+      GetProfile(), 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];
     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())) {
       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) {
     tabs->push_back(CreateTabModel(session_tag, *tabs_in_window[i], i,
-                                   window.selected_tab_index));
+                                   window.selected_tab_index == (int)i));
   }
 
   std::string session_id =
       SessionId(session_tag, window.window_id.id()).ToString();
 
   windows::WindowType type = windows::WINDOW_TYPE_NONE;
   switch (window.type) {
     case sessions::SessionWindow::TYPE_TABBED:
       type = windows::WINDOW_TYPE_NORMAL;
       break;
@@ skipping 138 matching lines @@
       windows::Window::FromValue(*window_value));
   results_ = Restore::Results::Create(*CreateSessionModelHelper(
       base::Time::Now().ToTimeT(), std::unique_ptr<tabs::Tab>(),
       std::move(window)));
   return true;
 }
 
 bool SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
   sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
-  sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
+  const sessions::TabRestoreService::Entries& entries =
+      tab_restore_service->entries();
 
   if (entries.empty()) {
     SetError(kNoRecentlyClosedSessionsError);
     return false;
   }
 
-  bool is_window = is_window_entry(entries.front());
+  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(
         ExtensionTabUtil::GetWindowIdOfTab(first_tab->web_contents()));
   }
 
   SetResultRestoredTab(first_tab->web_contents());
   return true;
 }
 
 bool SessionsRestoreFunction::RestoreLocalSession(const SessionId& session_id,
                                                   Browser* browser) {
   sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
-  sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
+  const sessions::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 (sessions::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
+  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(*it);
+      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(), UNKNOWN);
   // If the ID is invalid, restored_tabs will be empty.
@@ skipping 148 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