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

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 112 matching lines @@
   window_struct->focused = false;
   window_struct->type = type;
   window_struct->state = state;
   return window_struct;
 }
 
 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);
+  scoped_ptr<api::sessions::Session> session_struct(
+      new api::sessions::Session());
   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;
 }
 
@@ skipping 63 matching lines @@
 bool SessionsGetRecentlyClosedFunction::RunSync() {
   scoped_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<linked_ptr<api::sessions::Session> > result;
+  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(
-        std::vector<linked_ptr<api::sessions::Session> >());
+    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.
-  sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
-  for (sessions::TabRestoreService::Entries::const_iterator it =
-           entries.begin();
-       it != entries.end() && static_cast<int>(result.size()) < max_results;
-       ++it) {
-    sessions::TabRestoreService::Entry* entry = *it;
-    result.push_back(make_linked_ptr(CreateSessionModel(entry).release()));
+  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(
     const std::string& session_tag,
     const sessions::SessionTab& tab,
     int tab_index,
@@ skipping 91 matching lines @@
   scoped_ptr<windows::Window> window_model(
       CreateWindowModel(window, session_tag));
   // There is a chance that after pruning uninteresting tabs the window will be
   // empty.
   return !window_model ? scoped_ptr<api::sessions::Session>()
                        : CreateSessionModelHelper(window.timestamp.ToTimeT(),
                                                   scoped_ptr<tabs::Tab>(),
                                                   std::move(window_model));
 }
 
-scoped_ptr<api::sessions::Device> SessionsGetDevicesFunction::CreateDeviceModel(
+api::sessions::Device SessionsGetDevicesFunction::CreateDeviceModel(
     const sync_driver::SyncedSession* session) {
   int max_results = api::sessions::MAX_SESSION_RESULTS;
   // Already validated in RunAsync().
   scoped_ptr<GetDevices::Params> params(GetDevices::Params::Create(*args_));
   if (params->filter && params->filter->max_results)
     max_results = *params->filter->max_results;
 
-  scoped_ptr<api::sessions::Device> device_struct(new api::sessions::Device);
-  device_struct->info = session->session_name;
-  device_struct->device_name = session->session_name;
+  api::sessions::Device device_struct;
+  device_struct.info = session->session_name;
+  device_struct.device_name = session->session_name;
 
   for (sync_driver::SyncedSession::SyncedWindowMap::const_iterator it =
            session->windows.begin();
        it != session->windows.end() &&
-           static_cast<int>(device_struct->sessions.size()) < max_results;
+       static_cast<int>(device_struct.sessions.size()) < max_results;
        ++it) {
     scoped_ptr<api::sessions::Session> session_model(CreateSessionModel(
         *it->second, session->session_tag));
     if (session_model)
-      device_struct->sessions.push_back(make_linked_ptr(
-          session_model.release()));
+      device_struct.sessions.push_back(std::move(*session_model));
   }
   return device_struct;
 }
 
 bool SessionsGetDevicesFunction::RunSync() {
   ProfileSyncService* service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(GetProfile());
   if (!(service && service->GetPreferredDataTypes().Has(syncer::SESSIONS))) {
     // Sync not enabled.
-    results_ = GetDevices::Results::Create(
-        std::vector<linked_ptr<api::sessions::Device> >());
+    results_ =
+        GetDevices::Results::Create(std::vector<api::sessions::Device>());
     return true;
   }
 
   sync_driver::OpenTabsUIDelegate* open_tabs = service->GetOpenTabsUIDelegate();
   std::vector<const sync_driver::SyncedSession*> sessions;
   if (!(open_tabs && open_tabs->GetAllForeignSessions(&sessions))) {
-    results_ = GetDevices::Results::Create(
-        std::vector<linked_ptr<api::sessions::Device> >());
+    results_ =
+        GetDevices::Results::Create(std::vector<api::sessions::Device>());
     return true;
   }
 
   scoped_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<linked_ptr<api::sessions::Device> > result;
+  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(make_linked_ptr(CreateDeviceModel(sessions[i]).release()));
-  }
+  for (size_t i = 0; i < sessions.size(); ++i)
+    result.push_back(CreateDeviceModel(sessions[i]));
 
   results_ = GetDevices::Results::Create(result);
   return true;
 }
 
 void SessionsRestoreFunction::SetInvalidIdError(const std::string& invalid_id) {
   SetError(ErrorUtils::FormatErrorMessage(kInvalidSessionIdError, invalid_id));
 }
 
 
@@ skipping 231 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