Global conversion of Pass()→std::move() on OS=linux chromecast=1

(╯^□^)╯︵ ❄☃❄

BUG=557422
R=avi@chromium.org
TBR=jam@chromium.org

Review URL: https://codereview.chromium.org/1553493002

Cr-Commit-Position: refs/heads/master@{#367050}

base/feature_list_unittest.cc

@@ -332,7 +332,7 @@ TEST_F(FeatureListTest, GetFeatureOverrides) {
                                            FeatureList::OVERRIDE_ENABLE_FEATURE,
                                            trial);
 
-  RegisterFeatureListInstance(feature_list.Pass());
+  RegisterFeatureListInstance(std::move(feature_list));
 
   std::string enable_features;
   std::string disable_features;
@@ -348,7 +348,7 @@ TEST_F(FeatureListTest, InitializeFromCommandLine_WithFieldTrials) {
   FieldTrialList::CreateFieldTrial("Trial", "Group");
   scoped_ptr<FeatureList> feature_list(new FeatureList);
   feature_list->InitializeFromCommandLine("A,OffByDefault<Trial,X", "D");
-  RegisterFeatureListInstance(feature_list.Pass());
+  RegisterFeatureListInstance(std::move(feature_list));
 
   EXPECT_FALSE(FieldTrialList::IsTrialActive("Trial"));
   EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));

cloud_print/gcp20/prototype/cloud_print_request.cc

@@ -5,6 +5,7 @@
 #include "cloud_print/gcp20/prototype/cloud_print_request.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -56,7 +57,7 @@ scoped_ptr<CloudPrintRequest> CloudPrintRequest::CreatePost(
   scoped_ptr<CloudPrintRequest> request(
       new CloudPrintRequest(url, URLFetcher::POST, delegate));
   request->fetcher_->SetUploadData(mimetype, content);
-  return request.Pass();
+  return std::move(request);
 }
 
 void CloudPrintRequest::Run(

cloud_print/gcp20/prototype/cloud_print_requester.cc

@@ -5,8 +5,8 @@
 #include "cloud_print/gcp20/prototype/cloud_print_requester.h"
 
 #include <stdint.h>
-
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
@@ -90,7 +90,7 @@ std::string LocalSettingsToJson(const LocalSettings& settings) {
   current->SetBoolean("printer/local_printing_enabled",
                          settings.local_printing_enabled);
   current->SetInteger("xmpp_timeout_value", settings.xmpp_timeout_value);
-  dictionary.Set("current", current.Pass());
+  dictionary.Set("current", std::move(current));
 
   std::string local_settings;
   base::JSONWriter::Write(dictionary, &local_settings);

cloud_print/gcp20/prototype/cloud_print_url_request_context_getter.cc

@@ -4,6 +4,8 @@
 
 #include "cloud_print/gcp20/prototype/cloud_print_url_request_context_getter.h"
 
+#include <utility>
+
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
@@ -25,7 +27,7 @@ CloudPrintURLRequestContextGetter::GetURLRequestContext() {
     builder.set_proxy_config_service(
         make_scoped_ptr(new net::ProxyConfigServiceFixed(net::ProxyConfig())));
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
-    context_ = builder.Build().Pass();
+    context_ = std::move(builder.Build());
   }
   return context_.get();
 }

cloud_print/gcp20/prototype/privet_http_server.cc

@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ -34,7 +35,7 @@ scoped_ptr<base::DictionaryValue> CreateError(const std::string& error_type) {
   scoped_ptr<base::DictionaryValue> error(new base::DictionaryValue);
   error->SetString("error", error_type);
 
-  return error.Pass();
+  return std::move(error);
 }
 
 // {"error":|error_type|, "description":|description|}
@@ -43,7 +44,7 @@ scoped_ptr<base::DictionaryValue> CreateErrorWithDescription(
     const std::string& description) {
   scoped_ptr<base::DictionaryValue> error(CreateError(error_type));
   error->SetString("description", description);
-  return error.Pass();
+  return std::move(error);
 }
 
 // {"error":|error_type|, "timeout":|timeout|}
@@ -52,7 +53,7 @@ scoped_ptr<base::DictionaryValue> CreateErrorWithTimeout(
     int timeout) {
   scoped_ptr<base::DictionaryValue> error(CreateError(error_type));
   error->SetInteger("timeout", timeout);
-  return error.Pass();
+  return std::move(error);
 }
 
 // Converts state to string.
@@ -115,7 +116,7 @@ bool PrivetHttpServer::Start(uint16_t port) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableIpv6))
     listen_address = "0.0.0.0";
   server_socket->ListenWithAddressAndPort(listen_address, port, 1);
-  server_.reset(new net::HttpServer(server_socket.Pass(), this));
+  server_.reset(new net::HttpServer(std::move(server_socket), this));
 
   net::IPEndPoint address;
   if (server_->GetLocalAddress(&address) != net::OK) {
@@ -277,7 +278,7 @@ scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessInfo(
   response->Set("type", type.DeepCopy());
 
   *status_code = net::HTTP_OK;
-  return response.Pass();
+  return std::move(response);
 }
 
 scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessCapabilities(
@@ -316,7 +317,7 @@ scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessCreateJob(
       response.reset(new base::DictionaryValue);
       response->SetString("job_id", job_id);
       response->SetInteger("expires_in", expires_in);
-      return response.Pass();
+      return std::move(response);
 
     case LocalPrintJob::CREATE_INVALID_TICKET:
       return CreateError("invalid_ticket");
@@ -376,7 +377,7 @@ scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessSubmitDoc(
           base::StringPrintf("%u", static_cast<uint32_t>(job.content.size())));
       if (job_name_present)
         response->SetString("job_name", job.job_name);
-      return response.Pass();
+      return std::move(response);
 
     case LocalPrintJob::SAVE_INVALID_PRINT_JOB:
       return CreateErrorWithTimeout("invalid_print_job", timeout);
@@ -414,7 +415,7 @@ scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessJobState(
   response->SetString("job_id", job_id);
   response->SetString("state", LocalPrintJobStateToString(info.state));
   response->SetInteger("expires_in", info.expires_in);
-  return response.Pass();
+  return std::move(response);
 }
 
 scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessRegister(
@@ -465,7 +466,7 @@ scoped_ptr<base::DictionaryValue> PrivetHttpServer::ProcessRegister(
 
   ProcessRegistrationStatus(status, &response);
   *status_code = net::HTTP_OK;
-  return response.Pass();
+  return std::move(response);
 }
 
 void PrivetHttpServer::ProcessRegistrationStatus(

content/browser/compositor/browser_compositor_overlay_candidate_validator_ozone.cc

@@ -5,6 +5,7 @@
 #include "content/browser/compositor/browser_compositor_overlay_candidate_validator_ozone.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
@@ -29,9 +30,8 @@ BrowserCompositorOverlayCandidateValidatorOzone::
         gfx::AcceleratedWidget widget,
         scoped_ptr<ui::OverlayCandidatesOzone> overlay_candidates)
     : widget_(widget),
-      overlay_candidates_(overlay_candidates.Pass()),
-      software_mirror_active_(false) {
-}
+      overlay_candidates_(std::move(overlay_candidates)),
+      software_mirror_active_(false) {}
 
 BrowserCompositorOverlayCandidateValidatorOzone::
     ~BrowserCompositorOverlayCandidateValidatorOzone() {

content/browser/compositor/gpu_process_transport_factory.cc

@@ -176,7 +176,7 @@ CreateOverlayCandidateValidator(gfx::AcceleratedWidget widget) {
       (command_line->HasSwitch(switches::kEnableHardwareOverlays) ||
        command_line->HasSwitch(switches::kOzoneTestSingleOverlaySupport))) {
     validator.reset(new BrowserCompositorOverlayCandidateValidatorOzone(
-        widget, overlay_candidates.Pass()));
+        widget, std::move(overlay_candidates)));
   }
 #elif defined(OS_MACOSX)
   // Overlays are only supported through the remote layer API.

content/browser/media/cdm/browser_cdm_manager.cc

@@ -5,8 +5,8 @@
 #include "content/browser/media/cdm/browser_cdm_manager.h"
 
 #include <stddef.h>
-
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -426,7 +426,7 @@ void BrowserCdmManager::OnSetServerCertificate(
     return;
   }
 
-  cdm->SetServerCertificate(certificate, promise.Pass());
+  cdm->SetServerCertificate(certificate, std::move(promise));
 }
 
 void BrowserCdmManager::OnCreateSessionAndGenerateRequest(
@@ -540,7 +540,7 @@ void BrowserCdmManager::OnUpdateSession(int render_frame_id,
     return;
   }
 
-  cdm->UpdateSession(session_id, response, promise.Pass());
+  cdm->UpdateSession(session_id, response, std::move(promise));
 }
 
 void BrowserCdmManager::OnCloseSession(int render_frame_id,
@@ -558,7 +558,7 @@ void BrowserCdmManager::OnCloseSession(int render_frame_id,
     return;
   }
 
-  cdm->CloseSession(session_id, promise.Pass());
+  cdm->CloseSession(session_id, std::move(promise));
 }
 
 void BrowserCdmManager::OnRemoveSession(int render_frame_id,
@@ -576,7 +576,7 @@ void BrowserCdmManager::OnRemoveSession(int render_frame_id,
     return;
   }
 
-  cdm->RemoveSession(session_id, promise.Pass());
+  cdm->RemoveSession(session_id, std::move(promise));
 }
 
 void BrowserCdmManager::OnDestroyCdm(int render_frame_id, int cdm_id) {
@@ -700,8 +700,8 @@ void BrowserCdmManager::CreateSessionAndGenerateRequestIfPermitted(
     return;
   }
 
-  cdm->CreateSessionAndGenerateRequest(session_type, init_data_type,
-                                       init_data, promise.Pass());
+  cdm->CreateSessionAndGenerateRequest(session_type, init_data_type, init_data,
+                                       std::move(promise));
 }
 
 void BrowserCdmManager::LoadSessionIfPermitted(
@@ -725,7 +725,7 @@ void BrowserCdmManager::LoadSessionIfPermitted(
     return;
   }
 
-  cdm->LoadSession(session_type, session_id, promise.Pass());
+  cdm->LoadSession(session_type, session_id, std::move(promise));
 }
 
 }  // namespace content

content/common/discardable_shared_memory_heap_perftest.cc

@@ -5,10 +5,10 @@
 #include "content/common/discardable_shared_memory_heap.h"
 
 #include <stddef.h>
-
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ -40,9 +40,9 @@ TEST(DiscardableSharedMemoryHeapTest, SearchFreeLists) {
     scoped_ptr<base::DiscardableSharedMemory> memory(
         new base::DiscardableSharedMemory);
     ASSERT_TRUE(memory->CreateAndMap(segment_size));
-    heap.MergeIntoFreeLists(heap.Grow(memory.Pass(), segment_size,
+    heap.MergeIntoFreeLists(heap.Grow(std::move(memory), segment_size,
                                       next_discardable_shared_memory_id++,
-                                      base::Bind(NullTask)).Pass());
+                                      base::Bind(NullTask)));
   }
 
   unsigned kSeed = 1;

content/common/gpu/client/gpu_memory_buffer_impl_ozone_native_pixmap.cc

@@ -4,6 +4,8 @@
 
 #include "content/common/gpu/client/gpu_memory_buffer_impl_ozone_native_pixmap.h"
 
+#include <utility>
+
 #include "content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/ozone/public/client_native_pixmap_factory.h"
@@ -27,7 +29,8 @@ GpuMemoryBufferImplOzoneNativePixmap::GpuMemoryBufferImplOzoneNativePixmap(
     gfx::BufferFormat format,
     const DestructionCallback& callback,
     scoped_ptr<ui::ClientNativePixmap> pixmap)
-    : GpuMemoryBufferImpl(id, size, format, callback), pixmap_(pixmap.Pass()) {}
+    : GpuMemoryBufferImpl(id, size, format, callback),
+      pixmap_(std::move(pixmap)) {}
 
 GpuMemoryBufferImplOzoneNativePixmap::~GpuMemoryBufferImplOzoneNativePixmap() {}
 
@@ -44,7 +47,7 @@ GpuMemoryBufferImplOzoneNativePixmap::CreateFromHandle(
           handle.native_pixmap_handle, size, usage);
   DCHECK(native_pixmap);
   return make_scoped_ptr(new GpuMemoryBufferImplOzoneNativePixmap(
-      handle.id, size, format, callback, native_pixmap.Pass()));
+      handle.id, size, format, callback, std::move(native_pixmap)));
 }
 
 // static

content/renderer/media/cdm/proxy_media_keys.cc

@@ -4,6 +4,7 @@
 
 #include "content/renderer/media/cdm/proxy_media_keys.h"
 
+#include <utility>
 #include <vector>
 
 #include "base/logging.h"
@@ -37,13 +38,13 @@ void ProxyMediaKeys::Create(
       new media::CdmInitializedPromise(cdm_created_cb, proxy_media_keys));
 
   proxy_media_keys->InitializeCdm(key_system, security_origin,
-                                  use_hw_secure_codecs, promise.Pass());
+                                  use_hw_secure_codecs, std::move(promise));
 }
 
 void ProxyMediaKeys::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<media::SimpleCdmPromise> promise) {
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->SetServerCertificate(cdm_id_, promise_id, certificate);
 }
 
@@ -69,7 +70,7 @@ void ProxyMediaKeys::CreateSessionAndGenerateRequest(
       return;
   }
 
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->CreateSessionAndGenerateRequest(cdm_id_, promise_id, session_type,
                                             create_session_init_data_type,
                                             init_data);
@@ -79,28 +80,28 @@ void ProxyMediaKeys::LoadSession(
     SessionType session_type,
     const std::string& session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->LoadSession(cdm_id_, promise_id, session_type, session_id);
 }
 
 void ProxyMediaKeys::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     scoped_ptr<media::SimpleCdmPromise> promise) {
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->UpdateSession(cdm_id_, promise_id, session_id, response);
 }
 
 void ProxyMediaKeys::CloseSession(const std::string& session_id,
                                   scoped_ptr<media::SimpleCdmPromise> promise) {
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->CloseSession(cdm_id_, promise_id, session_id);
 }
 
 void ProxyMediaKeys::RemoveSession(
     const std::string& session_id,
     scoped_ptr<media::SimpleCdmPromise> promise) {
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->RemoveSession(cdm_id_, promise_id, session_id);
 }
 
@@ -141,7 +142,7 @@ void ProxyMediaKeys::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          media::CdmKeysInfo keys_info) {
   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
-                              keys_info.Pass());
+                              std::move(keys_info));
 }
 
 void ProxyMediaKeys::OnSessionExpirationUpdate(
@@ -195,7 +196,7 @@ void ProxyMediaKeys::InitializeCdm(
     const GURL& security_origin,
     bool use_hw_secure_codecs,
     scoped_ptr<media::SimpleCdmPromise> promise) {
-  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(std::move(promise));
   manager_->InitializeCdm(cdm_id_, promise_id, this, key_system,
                           security_origin, use_hw_secure_codecs);
 }