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 122 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;
+namespace {
+
+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,

[sky, 2016/08/04 16:34:38]

While you're cleaning up it seems like session_id is always tab.id. Is that
right? If so, how about removing it.

[Sidney San Martín, 2016/08/09 04:10:52]

Done! I also made a couple of other small changes here, LMK how they look.

     int selected_index) {
   return CreateTabModelHelper(GetProfile(),
                               tab.navigations[tab.current_navigation_index],
                               base::IntToString(session_id),
                               tab.tabstrip_index,
                               tab.pinned,
                               selected_index,
                               extension());
 }
 
 std::unique_ptr<windows::Window>
 SessionsGetRecentlyClosedFunction::CreateWindowModel(
     const sessions::TabRestoreService::Window& window,
     int session_id) {
   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->id, window.selected_tab_index));
 
   return CreateWindowModelHelper(std::move(tabs), base::IntToString(session_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), entry.id,
+          -1)));
       break;
     case sessions::TabRestoreService::WINDOW:
       window = CreateWindowModel(
-          *static_cast<const sessions::TabRestoreService::Window*>(entry),
-          entry->id);
+          static_cast<const sessions::TabRestoreService::Window&>(entry),
+          entry.id);
       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,
@@ skipping 187 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