Convert Pass()→std::move() in //components/[n-z]*

components/nacl/renderer/ppb_nacl_private_impl.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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
-
 #include <numeric>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
@@ skipping 508 matching lines @@
 
   // Create the trusted plugin channel.
   if (IsValidChannelHandle(launch_result.trusted_ipc_channel_handle)) {
     bool is_helper_nexe = !PP_ToBool(main_service_runtime);
     scoped_ptr<TrustedPluginChannel> trusted_plugin_channel(
         new TrustedPluginChannel(
             load_manager,
             launch_result.trusted_ipc_channel_handle,
             content::RenderThread::Get()->GetShutdownEvent(),
             is_helper_nexe));
-    load_manager->set_trusted_plugin_channel(trusted_plugin_channel.Pass());
+    load_manager->set_trusted_plugin_channel(std::move(trusted_plugin_channel));
   } else {
     PostPPCompletionCallback(callback, PP_ERROR_FAILED);
     return;
   }
 
   // Create the manifest service handle as well.
   if (IsValidChannelHandle(launch_result.manifest_service_ipc_channel_handle)) {
     scoped_ptr<ManifestServiceChannel> manifest_service_channel(
         new ManifestServiceChannel(
             launch_result.manifest_service_ipc_channel_handle,
             base::Bind(&PostPPCompletionCallback, callback),
-            manifest_service_proxy.Pass(),
+            std::move(manifest_service_proxy),
             content::RenderThread::Get()->GetShutdownEvent()));
     load_manager->set_manifest_service_channel(
-        manifest_service_channel.Pass());
+        std::move(manifest_service_channel));
   }
 }
 
 PP_Bool StartPpapiProxy(PP_Instance instance) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_FALSE;
 
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
     DLOG(ERROR) << "GetInstance() failed";
     return PP_FALSE;
   }
 
   NaClPluginInstance* nacl_plugin_instance = GetNaClPluginInstance(instance);
   if (!nacl_plugin_instance->instance_info) {
     DLOG(ERROR) << "Could not find instance ID";
     return PP_FALSE;
   }
   scoped_ptr<InstanceInfo> instance_info =
-      nacl_plugin_instance->instance_info.Pass();
+      std::move(nacl_plugin_instance->instance_info);
 
   PP_ExternalPluginResult result = plugin_instance->SwitchToOutOfProcessProxy(
       base::FilePath().AppendASCII(instance_info->url.spec()),
       instance_info->permissions,
       instance_info->channel_handle,
       instance_info->plugin_pid,
       instance_info->plugin_child_id);
 
   if (result == PP_EXTERNAL_PLUGIN_OK) {
     // Log the amound of time that has passed between the trusted plugin being
@@ skipping 267 matching lines @@
                      const char* error_message) {
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   if (load_manager)
     load_manager->ReportLoadError(error, error_message);
 }
 
 void InstanceCreated(PP_Instance instance) {
   InstanceMap& map = g_instance_map.Get();
   CHECK(map.find(instance) == map.end()); // Sanity check.
   scoped_ptr<NaClPluginInstance> new_instance(new NaClPluginInstance(instance));
-  map.add(instance, new_instance.Pass());
+  map.add(instance, std::move(new_instance));
 }
 
 void InstanceDestroyed(PP_Instance instance) {
   InstanceMap& map = g_instance_map.Get();
   InstanceMap::iterator iter = map.find(instance);
   CHECK(iter != map.end());
   // The erase may call NexeLoadManager's destructor prior to removing it from
   // the map. In that case, it is possible for the trusted Plugin to re-enter
   // the NexeLoadManager (e.g., by calling ReportLoadError). Passing out the
   // NexeLoadManager to a local scoped_ptr just ensures that its entry is gone
@@ skipping 122 matching lines @@
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
 
   const GURL& gurl = load_manager->manifest_base_url();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   blink::WebURLRequest request = CreateWebURLRequest(document, gurl);
 
   // ManifestDownloader deletes itself after invoking the callback.
   ManifestDownloader* manifest_downloader = new ManifestDownloader(
-      url_loader.Pass(),
-      load_manager->is_installed(),
-      base::Bind(DownloadManifestToBufferCompletion,
-                 instance, callback, base::Time::Now()));
+      std::move(url_loader), load_manager->is_installed(),
+      base::Bind(DownloadManifestToBufferCompletion, instance, callback,
+                 base::Time::Now()));
   manifest_downloader->Load(request);
 }
 
 void DownloadManifestToBufferCompletion(PP_Instance instance,
                                         struct PP_CompletionCallback callback,
                                         base::Time start_time,
                                         PP_NaClError pp_nacl_error,
                                         const std::string& data) {
   base::TimeDelta download_time = base::Time::Now() - start_time;
   HistogramTimeSmall("NaCl.Perf.StartupTime.ManifestDownload",
@@ skipping 318 matching lines @@
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
 
   ProgressEventRateLimiter* tracker = new ProgressEventRateLimiter(instance);
 
   // FileDownloader deletes itself after invoking DownloadNexeCompletion.
   FileDownloader* file_downloader = new FileDownloader(
-      url_loader.Pass(),
-      target_file.Pass(),
+      std::move(url_loader), std::move(target_file),
       base::Bind(&DownloadNexeCompletion, request, out_file_info),
       base::Bind(&ProgressEventRateLimiter::ReportProgress,
                  base::Owned(tracker), std::string(url)));
   file_downloader->Load(url_request);
 }
 
 void DownloadNexeCompletion(const DownloadNexeRequest& request,
                             PP_NaClFileInfo* out_file_info,
                             FileDownloader::Status status,
                             base::File target_file,
@@ skipping 127 matching lines @@
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
 
   ProgressEventRateLimiter* tracker = new ProgressEventRateLimiter(instance);
 
   // FileDownloader deletes itself after invoking DownloadNexeCompletion.
-  FileDownloader* file_downloader = new FileDownloader(
-      url_loader.Pass(),
-      target_file.Pass(),
-      base::Bind(&DownloadFileCompletion, callback),
-      base::Bind(&ProgressEventRateLimiter::ReportProgress,
-                 base::Owned(tracker), std::string(url)));
+  FileDownloader* file_downloader =
+      new FileDownloader(std::move(url_loader), std::move(target_file),
+                         base::Bind(&DownloadFileCompletion, callback),
+                         base::Bind(&ProgressEventRateLimiter::ReportProgress,
+                                    base::Owned(tracker), std::string(url)));
   file_downloader->Load(url_request);
 }
 
 void LogTranslateTime(const char* histogram_name,
                       int64_t time_in_us) {
   ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
       FROM_HERE,
       base::Bind(&HistogramTimeTranslation,
                  std::string(histogram_name),
                  time_in_us / 1000));
@@ skipping 22 matching lines @@
 class PexeDownloader : public blink::WebURLLoaderClient {
  public:
   PexeDownloader(PP_Instance instance,
                  scoped_ptr<blink::WebURLLoader> url_loader,
                  const std::string& pexe_url,
                  int32_t pexe_opt_level,
                  bool use_subzero,
                  const PPP_PexeStreamHandler* stream_handler,
                  void* stream_handler_user_data)
       : instance_(instance),
-        url_loader_(url_loader.Pass()),
+        url_loader_(std::move(url_loader)),
         pexe_url_(pexe_url),
         pexe_opt_level_(pexe_opt_level),
         use_subzero_(use_subzero),
         stream_handler_(stream_handler),
         stream_handler_user_data_(stream_handler_user_data),
         success_(false),
         expected_content_length_(-1),
         weak_factory_(this) {}
 
   void Load(const blink::WebURLRequest& request) {
@@ skipping 120 matching lines @@
                               static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   GURL gurl(pexe_url);
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   PexeDownloader* downloader =
-      new PexeDownloader(instance, url_loader.Pass(), pexe_url, opt_level,
+      new PexeDownloader(instance, std::move(url_loader), pexe_url, opt_level,
                          PP_ToBool(use_subzero), handler, handler_user_data);
 
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
   // Mark the request as requesting a PNaCl bitcode file,
   // so that component updater can detect this user action.
   url_request.addHTTPHeaderField(
       blink::WebString::fromUTF8("Accept"),
       blink::WebString::fromUTF8("application/x-pnacl, */*"));
   url_request.setRequestContext(blink::WebURLRequest::RequestContextObject);
   downloader->Load(url_request);
@@ skipping 27 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl