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

components/nacl/browser/nacl_process_host.cc

 // Copyright (c) 2012 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/browser/nacl_process_host.h"
 
 #include <string.h>
-
 #include <algorithm>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
@@ skipping 261 matching lines @@
     const NaClFileToken& nexe_token,
     const std::vector<NaClResourcePrefetchResult>& prefetched_resource_files,
     ppapi::PpapiPermissions permissions,
     int render_view_id,
     uint32_t permission_bits,
     bool uses_nonsfi_mode,
     bool off_the_record,
     NaClAppProcessType process_type,
     const base::FilePath& profile_directory)
     : manifest_url_(manifest_url),
-      nexe_file_(nexe_file.Pass()),
+      nexe_file_(std::move(nexe_file)),
       nexe_token_(nexe_token),
       prefetched_resource_files_(prefetched_resource_files),
       permissions_(permissions),
 #if defined(OS_WIN)
       process_launched_by_broker_(false),
 #endif
       reply_msg_(NULL),
 #if defined(OS_WIN)
       debug_exception_handler_requested_(false),
 #endif
@@ skipping 40 matching lines @@
   // prefetching feature only on POSIX platforms, so it should be ok.
 #if defined(OS_WIN)
   DCHECK(prefetched_resource_files_.empty());
 #else
   for (size_t i = 0; i < prefetched_resource_files_.size(); ++i) {
     // The process failed to launch for some reason. Close resource file
     // handles.
     base::File file(IPC::PlatformFileForTransitToFile(
         prefetched_resource_files_[i].file));
     content::BrowserThread::GetBlockingPool()->PostTask(
-        FROM_HERE,
-        base::Bind(&CloseFile, base::Passed(file.Pass())));
+        FROM_HERE, base::Bind(&CloseFile, base::Passed(std::move(file))));
   }
 #endif
   base::File files_to_close[] = {
-      nexe_file_.Pass(),
-      socket_for_renderer_.Pass(),
-      socket_for_sel_ldr_.Pass(),
+      std::move(nexe_file_), std::move(socket_for_renderer_),
+      std::move(socket_for_sel_ldr_),
   };
   // Open files need to be closed on the blocking pool.
   for (auto& file : files_to_close) {
     if (file.IsValid()) {
       content::BrowserThread::GetBlockingPool()->PostTask(
-          FROM_HERE,
-          base::Bind(&CloseFile, base::Passed(file.Pass())));
+          FROM_HERE, base::Bind(&CloseFile, base::Passed(std::move(file))));
     }
   }
 
   if (reply_msg_) {
     // The process failed to launch for some reason.
     // Don't keep the renderer hanging.
     reply_msg_->set_reply_error();
     nacl_host_message_filter_->Send(reply_msg_);
   }
 #if defined(OS_WIN)
@@ skipping 366 matching lines @@
   if (RunningOnWOW64()) {
     if (!content::BrokerAddTargetPeer(process_->GetData().handle)) {
       SendErrorToRenderer("BrokerAddTargetPeer() failed");
       return;
     }
   }
 #endif
 
   // First, create an |imc_channel_handle| for the renderer.
   IPC::PlatformFileForTransit imc_handle_for_renderer =
-      IPC::TakeFileHandleForProcess(socket_for_renderer_.Pass(),
+      IPC::TakeFileHandleForProcess(std::move(socket_for_renderer_),
                                     nacl_host_message_filter_->PeerHandle());
   if (imc_handle_for_renderer == IPC::InvalidPlatformFileForTransit()) {
     // Failed to create the handle.
     SendErrorToRenderer("imc_channel_handle creation failed.");
     return;
   }
 
   // Hereafter, we always send an IPC message with handles including imc_handle
   // created above which, on Windows, are not closable in this process.
   std::string error_message;
@@ skipping 144 matching lines @@
       base::ProcessId pid = base::GetProcId(process_->GetData().handle);
       LOG(WARNING) << "nonsfi nacl plugin running in " << pid;
     }
   } else {
     params.validation_cache_enabled = nacl_browser->ValidationCacheIsEnabled();
     params.validation_cache_key = nacl_browser->GetValidationCacheKey();
     params.version = NaClBrowser::GetDelegate()->GetVersionString();
     params.enable_debug_stub = enable_nacl_debug;
 
     const ChildProcessData& data = process_->GetData();
-    params.imc_bootstrap_handle =
-        IPC::TakeFileHandleForProcess(socket_for_sel_ldr_.Pass(), data.handle);
+    params.imc_bootstrap_handle = IPC::TakeFileHandleForProcess(
+        std::move(socket_for_sel_ldr_), data.handle);
     if (params.imc_bootstrap_handle == IPC::InvalidPlatformFileForTransit()) {
       return false;
     }
 
     const base::File& irt_file = nacl_browser->IrtFile();
     CHECK(irt_file.IsValid());
     // Send over the IRT file handle.  We don't close our own copy!
     params.irt_handle = IPC::GetFileHandleForProcess(
         irt_file.GetPlatformFile(), data.handle, false);
     if (params.irt_handle == IPC::InvalidPlatformFileForTransit()) {
@@ skipping 93 matching lines @@
 }
 
 void NaClProcessHost::StartNaClFileResolved(
     NaClStartParams params,
     const base::FilePath& file_path,
     base::File checked_nexe_file) {
   if (checked_nexe_file.IsValid()) {
     // Release the file received from the renderer. This has to be done on a
     // thread where IO is permitted, though.
     content::BrowserThread::GetBlockingPool()->PostTask(
-        FROM_HERE,
-        base::Bind(&CloseFile, base::Passed(nexe_file_.Pass())));
+        FROM_HERE, base::Bind(&CloseFile, base::Passed(std::move(nexe_file_))));
     params.nexe_file_path_metadata = file_path;
     params.nexe_file = IPC::TakeFileHandleForProcess(
-        checked_nexe_file.Pass(), process_->GetData().handle);
+        std::move(checked_nexe_file), process_->GetData().handle);
   } else {
     params.nexe_file = IPC::TakeFileHandleForProcess(
-        nexe_file_.Pass(), process_->GetData().handle);
+        std::move(nexe_file_), process_->GetData().handle);
   }
 
 #if defined(OS_LINUX)
   // In Non-SFI mode, create socket pairs for IPC channels here, unlike in
   // SFI-mode, in which those channels are created in nacl_listener.cc.
   // This is for security hardening. We can then prohibit the socketpair()
   // system call in nacl_helper and nacl_helper_nonsfi.
   if (uses_nonsfi_mode_) {
     // Note: here, because some FDs/handles for the NaCl loader process are
     // already opened, they are transferred to NaCl loader process even if
@@ skipping 17 matching lines @@
                                  &ppapi_renderer_client_channel_handle) ||
         !CreateChannelHandlePair(&trusted_service_server_channel_handle,
                                  &trusted_service_client_channel_handle) ||
         !CreateChannelHandlePair(&manifest_service_server_channel_handle,
                                  &manifest_service_client_channel_handle)) {
       SendErrorToRenderer("Failed to create socket pairs.");
       has_error = true;
     }
 
     if (!has_error &&
-        !StartPPAPIProxy(ppapi_browser_client_channel_handle.Pass())) {
+        !StartPPAPIProxy(std::move(ppapi_browser_client_channel_handle))) {
       SendErrorToRenderer("Failed to start browser PPAPI proxy.");
       has_error = true;
     }
 
     if (!has_error) {
       // On success, send back a success message to the renderer process,
       // and transfer the channel handles for the NaCl loader process to
       // |params|.
-      ReplyToRenderer(ppapi_renderer_client_channel_handle.Pass(),
-                      trusted_service_client_channel_handle.Pass(),
-                      manifest_service_client_channel_handle.Pass());
+      ReplyToRenderer(std::move(ppapi_renderer_client_channel_handle),
+                      std::move(trusted_service_client_channel_handle),
+                      std::move(manifest_service_client_channel_handle));
       params.ppapi_browser_channel_handle =
           ppapi_browser_server_channel_handle.release();
       params.ppapi_renderer_channel_handle =
           ppapi_renderer_server_channel_handle.release();
       params.trusted_service_channel_handle =
           trusted_service_server_channel_handle.release();
       params.manifest_service_channel_handle =
           manifest_service_server_channel_handle.release();
     }
   }
@@ skipping 89 matching lines @@
     const IPC::ChannelHandle& raw_manifest_service_channel_handle) {
   ScopedChannelHandle ppapi_browser_channel_handle(
       raw_ppapi_browser_channel_handle);
   ScopedChannelHandle ppapi_renderer_channel_handle(
       raw_ppapi_renderer_channel_handle);
   ScopedChannelHandle trusted_renderer_channel_handle(
       raw_trusted_renderer_channel_handle);
   ScopedChannelHandle manifest_service_channel_handle(
       raw_manifest_service_channel_handle);
 
-  if (!StartPPAPIProxy(ppapi_browser_channel_handle.Pass())) {
+  if (!StartPPAPIProxy(std::move(ppapi_browser_channel_handle))) {
     SendErrorToRenderer("Browser PPAPI proxy could not start.");
     return;
   }
 
   // Let the renderer know that the IPC channels are established.
-  ReplyToRenderer(ppapi_renderer_channel_handle.Pass(),
-                  trusted_renderer_channel_handle.Pass(),
-                  manifest_service_channel_handle.Pass());
+  ReplyToRenderer(std::move(ppapi_renderer_channel_handle),
+                  std::move(trusted_renderer_channel_handle),
+                  std::move(manifest_service_channel_handle));
 }
 
 bool NaClProcessHost::StartWithLaunchedProcess() {
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
 
   if (nacl_browser->IsReady()) {
     return StartNaClExecution();
   } else if (nacl_browser->IsOk()) {
     nacl_browser->WaitForResources(
         base::Bind(&NaClProcessHost::OnResourcesReady,
@@ skipping 75 matching lines @@
 
 void NaClProcessHost::FileResolved(
     uint64_t file_token_lo,
     uint64_t file_token_hi,
     const base::FilePath& file_path,
     base::File file) {
   base::FilePath out_file_path;
   IPC::PlatformFileForTransit out_handle;
   if (file.IsValid()) {
     out_file_path = file_path;
-    out_handle = IPC::TakeFileHandleForProcess(
-        file.Pass(),
-        process_->GetData().handle);
+    out_handle = IPC::TakeFileHandleForProcess(std::move(file),
+                                               process_->GetData().handle);
   } else {
     out_handle = IPC::InvalidPlatformFileForTransit();
   }
   Send(new NaClProcessMsg_ResolveFileTokenReply(
            file_token_lo,
            file_token_hi,
            out_handle,
            out_file_path));
 }
 
@@ skipping 61 matching lines @@
     NaClStartDebugExceptionHandlerThread(
         process.Pass(), info, base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif
 
 }  // namespace nacl