[Extensions] Convert APIs to use movable types [14]

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 55 matching lines @@
   return s1->modified_time > s2->modified_time;
 }
 
 // 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;
 }
 
-scoped_ptr<tabs::Tab> CreateTabModelHelper(
+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);
+  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(
+  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));
+    tab_struct.title.reset(new std::string(title));
   } else {
     const std::string languages =
         profile->GetPrefs()->GetString(prefs::kAcceptLanguages);
-    tab_struct->title.reset(new std::string(
+    tab_struct.title.reset(new std::string(
         base::UTF16ToUTF8(url_formatter::FormatUrl(url, languages))));
   }
-  tab_struct->index = index;
-  tab_struct->pinned = pinned;
+  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;
-  ExtensionTabUtil::ScrubTabForExtension(extension, nullptr, tab_struct.get());
+  tab_struct.active = index == selected_index;
+  ExtensionTabUtil::ScrubTabForExtension(extension, nullptr, &tab_struct);
   return tab_struct;
 }
 
 scoped_ptr<windows::Window> CreateWindowModelHelper(
-    scoped_ptr<std::vector<linked_ptr<tabs::Tab>>> tabs,
+    scoped_ptr<std::vector<tabs::Tab>> tabs,
     const std::string& session_id,
     const windows::WindowType& type,
     const windows::WindowState& state) {
   scoped_ptr<windows::Window> window_struct(new windows::Window);
   window_struct->tabs = std::move(tabs);
   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;
@@ skipping 18 matching lines @@
 }
 
 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;
 }
 
-scoped_ptr<tabs::Tab> SessionsGetRecentlyClosedFunction::CreateTabModel(
+tabs::Tab SessionsGetRecentlyClosedFunction::CreateTabModel(
     const sessions::TabRestoreService::Tab& tab,
     int session_id,
     int selected_index) {
   return CreateTabModelHelper(GetProfile(),
                               tab.navigations[tab.current_navigation_index],
                               base::IntToString(session_id),
                               tab.tabstrip_index,
                               tab.pinned,
                               selected_index,
                               extension());
 }
 
 scoped_ptr<windows::Window>
 SessionsGetRecentlyClosedFunction::CreateWindowModel(
     const sessions::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> >);
+  scoped_ptr<std::vector<tabs::Tab>> tabs(new std::vector<tabs::Tab>());
   for (size_t i = 0; i < window.tabs.size(); ++i) {
-    tabs->push_back(make_linked_ptr(
-        CreateTabModel(window.tabs[i], window.tabs[i].id,
-                       window.selected_tab_index).release()));
+    tabs->push_back(CreateTabModel(window.tabs[i], window.tabs[i].id,
+                                   window.selected_tab_index));
   }
 
   return CreateWindowModelHelper(std::move(tabs), base::IntToString(session_id),
                                  windows::WINDOW_TYPE_NORMAL,
                                  windows::WINDOW_STATE_NORMAL);
 }
 
 scoped_ptr<api::sessions::Session>
 SessionsGetRecentlyClosedFunction::CreateSessionModel(
     const sessions::TabRestoreService::Entry* entry) {
   scoped_ptr<tabs::Tab> tab;
   scoped_ptr<windows::Window> window;
   switch (entry->type) {
     case sessions::TabRestoreService::TAB:
-      tab = CreateTabModel(
+      tab.reset(new tabs::Tab(CreateTabModel(
           *static_cast<const sessions::TabRestoreService::Tab*>(entry),
-          entry->id, -1);
+          entry->id, -1)));
       break;
     case sessions::TabRestoreService::WINDOW:
       window = CreateWindowModel(
           *static_cast<const sessions::TabRestoreService::Window*>(entry),
           entry->id);
       break;
     default:
       NOTREACHED();
   }
   return CreateSessionModelHelper(entry->timestamp.ToTimeT(), std::move(tab),
@@ skipping 28 matching lines @@
   // uninteresting entries.
   for (const sessions::TabRestoreService::Entry* entry :
        tab_restore_service->entries()) {
     result.push_back(std::move(*CreateSessionModel(entry)));
   }
 
   results_ = GetRecentlyClosed::Results::Create(result);
   return true;
 }
 
-scoped_ptr<tabs::Tab> SessionsGetDevicesFunction::CreateTabModel(
+tabs::Tab SessionsGetDevicesFunction::CreateTabModel(
     const std::string& session_tag,
     const sessions::SessionTab& tab,
     int tab_index,
     int selected_index) {
   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,
@@ skipping 17 matching lines @@
         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 scoped_ptr<windows::Window>();
   std::sort(tabs_in_window.begin(), tabs_in_window.end(), SortTabsByRecency);
 
-  scoped_ptr<std::vector<linked_ptr<tabs::Tab> > > tabs(
-      new std::vector<linked_ptr<tabs::Tab> >);
+  scoped_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(make_linked_ptr(
-        CreateTabModel(session_tag, *tabs_in_window[i], i,
-                       window.selected_tab_index).release()));
+    tabs->push_back(CreateTabModel(session_tag, *tabs_in_window[i], i,
+                                   window.selected_tab_index));
   }
 
   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 347 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