Convert Pass()→std::move() in //chrome/browser/extensions

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>
 
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/extensions/api/sessions/session_id.h"
@@ skipping 82 matching lines @@
   }
   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, tab_struct.get());
-  return tab_struct.Pass();
+  return tab_struct;
 }
 
 scoped_ptr<windows::Window> CreateWindowModelHelper(
     scoped_ptr<std::vector<linked_ptr<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 = tabs.Pass();
+  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;
   window_struct->state = state;
-  return window_struct.Pass();
+  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);
   session_struct->last_modified = last_modified;
   if (tab)
-    session_struct->tab = tab.Pass();
+    session_struct->tab = std::move(tab);
   else if (window)
-    session_struct->window = window.Pass();
+    session_struct->window = std::move(window);
   else
     NOTREACHED();
-  return session_struct.Pass();
+  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;
 }
 
@@ skipping 17 matching lines @@
   DCHECK(!window.tabs.empty());
 
   scoped_ptr<std::vector<linked_ptr<tabs::Tab> > > tabs(
       new std::vector<linked_ptr<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()));
   }
 
-  return CreateWindowModelHelper(tabs.Pass(), base::IntToString(session_id),
+  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(
           *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);
       break;
     default:
       NOTREACHED();
   }
-  return CreateSessionModelHelper(entry->timestamp.ToTimeT(),
-                                  tab.Pass(),
-                                  window.Pass());
+  return CreateSessionModelHelper(entry->timestamp.ToTimeT(), std::move(tab),
+                                  std::move(window));
 }
 
 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 &&
@@ skipping 103 matching lines @@
     case ui::SHOW_STATE_FULLSCREEN:
       state = windows::WINDOW_STATE_FULLSCREEN;
       break;
     case ui::SHOW_STATE_DEFAULT:
     case ui::SHOW_STATE_INACTIVE:
     case ui::SHOW_STATE_END:
       break;
   }
 
   scoped_ptr<windows::Window> window_struct(
-      CreateWindowModelHelper(tabs.Pass(), session_id, type, state));
+      CreateWindowModelHelper(std::move(tabs), session_id, type, state));
   // TODO(dwankri): Dig deeper to resolve bounds not being optional, so closed
   // windows in GetRecentlyClosed can have set values in Window helper.
   window_struct->left.reset(new int(window.bounds.x()));
   window_struct->top.reset(new int(window.bounds.y()));
   window_struct->width.reset(new int(window.bounds.width()));
   window_struct->height.reset(new int(window.bounds.height()));
 
-  return window_struct.Pass();
+  return window_struct;
 }
 
 scoped_ptr<api::sessions::Session>
 SessionsGetDevicesFunction::CreateSessionModel(
     const sessions::SessionWindow& window, const std::string& session_tag) {
   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>(),
-                                 window_model.Pass());
+                       : CreateSessionModelHelper(window.timestamp.ToTimeT(),
+                                                  scoped_ptr<tabs::Tab>(),
+                                                  std::move(window_model));
 }
 
 scoped_ptr<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;
 
   for (sync_driver::SyncedSession::SyncedWindowMap::const_iterator it =
            session->windows.begin();
        it != session->windows.end() &&
            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()));
   }
-  return device_struct.Pass();
+  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> >());
     return true;
@@ skipping 28 matching lines @@
 void SessionsRestoreFunction::SetInvalidIdError(const std::string& invalid_id) {
   SetError(ErrorUtils::FormatErrorMessage(kInvalidSessionIdError, invalid_id));
 }
 
 
 void SessionsRestoreFunction::SetResultRestoredTab(
     content::WebContents* contents) {
   scoped_ptr<base::DictionaryValue> tab_value(
       ExtensionTabUtil::CreateTabValue(contents, extension()));
   scoped_ptr<tabs::Tab> tab(tabs::Tab::FromValue(*tab_value));
-  scoped_ptr<api::sessions::Session> restored_session(CreateSessionModelHelper(
-      base::Time::Now().ToTimeT(),
-      tab.Pass(),
-      scoped_ptr<windows::Window>()));
+  scoped_ptr<api::sessions::Session> restored_session(
+      CreateSessionModelHelper(base::Time::Now().ToTimeT(), std::move(tab),
+                               scoped_ptr<windows::Window>()));
   results_ = Restore::Results::Create(*restored_session);
 }
 
 bool SessionsRestoreFunction::SetResultRestoredWindow(int window_id) {
   WindowController* controller = NULL;
   if (!windows_util::GetWindowFromWindowID(this, window_id, 0, &controller)) {
     // error_ is set by GetWindowFromWindowId function call.
     return false;
   }
   scoped_ptr<base::DictionaryValue> window_value(
       controller->CreateWindowValueWithTabs(extension()));
   scoped_ptr<windows::Window> window(windows::Window::FromValue(
       *window_value));
   results_ = Restore::Results::Create(*CreateSessionModelHelper(
-      base::Time::Now().ToTimeT(),
-      scoped_ptr<tabs::Tab>(),
-      window.Pass()));
+      base::Time::Now().ToTimeT(), scoped_ptr<tabs::Tab>(), std::move(window)));
   return true;
 }
 
 bool SessionsRestoreFunction::RestoreMostRecentlyClosed(Browser* browser) {
   sessions::TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(GetProfile());
   chrome::HostDesktopType host_desktop_type = browser->host_desktop_type();
   sessions::TabRestoreService::Entries entries = tab_restore_service->entries();
 
   if (entries.empty()) {
@@ skipping 168 matching lines @@
 SessionsEventRouter::~SessionsEventRouter() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 }
 
 void SessionsEventRouter::TabRestoreServiceChanged(
     sessions::TabRestoreService* service) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   EventRouter::Get(profile_)->BroadcastEvent(make_scoped_ptr(
       new Event(events::SESSIONS_ON_CHANGED,
-                api::sessions::OnChanged::kEventName, args.Pass())));
+                api::sessions::OnChanged::kEventName, std::move(args))));
 }
 
 void SessionsEventRouter::TabRestoreServiceDestroyed(
     sessions::TabRestoreService* service) {
   tab_restore_service_ = NULL;
 }
 
 SessionsAPI::SessionsAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter::Get(browser_context_)->RegisterObserver(this,
@@ skipping 15 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