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

components/nacl/browser/nacl_file_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_file_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/nacl/browser/bad_message.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/nacl_browser_delegate.h"
@@ skipping 35 matching lines @@
     WriteFileInfoReply write_reply_message) {
   // IO thread owns the NaClBrowser singleton.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   nacl::NaClBrowser* nacl_browser = nacl::NaClBrowser::GetInstance();
   uint64_t file_token_lo = 0;
   uint64_t file_token_hi = 0;
   nacl_browser->PutFilePath(file_path, &file_token_lo, &file_token_hi);
 
   IPC::PlatformFileForTransit file_desc = IPC::TakeFileHandleForProcess(
-      file.Pass(),
-      nacl_host_message_filter->PeerHandle());
+      std::move(file), nacl_host_message_filter->PeerHandle());
 
   write_reply_message(reply_msg, file_desc, file_token_lo, file_token_hi);
   nacl_host_message_filter->Send(reply_msg);
 }
 
 void DoOpenPnaclFile(
     scoped_refptr<nacl::NaClHostMessageFilter> nacl_host_message_filter,
     const std::string& filename,
     bool is_executable,
     IPC::Message* reply_msg) {
@@ skipping 22 matching lines @@
   }
 
   // This function is running on the blocking pool, but the path needs to be
   // registered in a structure owned by the IO thread.
   // Not all PNaCl files are executable. Only register those that are
   // executable in the NaCl file_path cache.
   if (is_executable) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&DoRegisterOpenedNaClExecutableFile,
-                   nacl_host_message_filter,
-                   Passed(file_to_open.Pass()), full_filepath, reply_msg,
+                   nacl_host_message_filter, Passed(std::move(file_to_open)),
+                   full_filepath, reply_msg,
                    static_cast<WriteFileInfoReply>(
                        NaClHostMsg_GetReadonlyPnaclFD::WriteReplyParams)));
   } else {
-    IPC::PlatformFileForTransit target_desc =
-        IPC::TakeFileHandleForProcess(file_to_open.Pass(),
-                                      nacl_host_message_filter->PeerHandle());
+    IPC::PlatformFileForTransit target_desc = IPC::TakeFileHandleForProcess(
+        std::move(file_to_open), nacl_host_message_filter->PeerHandle());
     uint64_t dummy_file_token = 0;
     NaClHostMsg_GetReadonlyPnaclFD::WriteReplyParams(
         reply_msg, target_desc, dummy_file_token, dummy_file_token);
     nacl_host_message_filter->Send(reply_msg);
   }
 }
 
 // Convert the file URL into a file descriptor.
 // This function is security sensitive.  Be sure to check with a security
 // person before you modify it.
@@ skipping 20 matching lines @@
     // Opening a NaCl executable works with or without validation caching.
     // Validation caching requires that the file descriptor is registered now
     // for later use, which will save time.
     // When validation caching isn't used (e.g. Non-SFI mode), there is no
     // reason to do that unnecessary registration.
     if (enable_validation_caching) {
       // This function is running on the blocking pool, but the path needs to be
       // registered in a structure owned by the IO thread.
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(
-              &DoRegisterOpenedNaClExecutableFile,
-              nacl_host_message_filter,
-              Passed(file.Pass()), file_path, reply_msg,
-              static_cast<WriteFileInfoReply>(
-                  NaClHostMsg_OpenNaClExecutable::WriteReplyParams)));
+          base::Bind(&DoRegisterOpenedNaClExecutableFile,
+                     nacl_host_message_filter, Passed(std::move(file)),
+                     file_path, reply_msg,
+                     static_cast<WriteFileInfoReply>(
+                         NaClHostMsg_OpenNaClExecutable::WriteReplyParams)));
     } else {
-      IPC::PlatformFileForTransit file_desc =
-          IPC::TakeFileHandleForProcess(file.Pass(),
-                                        nacl_host_message_filter->PeerHandle());
+      IPC::PlatformFileForTransit file_desc = IPC::TakeFileHandleForProcess(
+          std::move(file), nacl_host_message_filter->PeerHandle());
       uint64_t dummy_file_token = 0;
       NaClHostMsg_OpenNaClExecutable::WriteReplyParams(
           reply_msg, file_desc, dummy_file_token, dummy_file_token);
       nacl_host_message_filter->Send(reply_msg);
     }
   } else {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
     return;
   }
 }
@@ skipping 99 matching lines @@
           &DoOpenNaClExecutableOnThreadPool,
           nacl_host_message_filter,
           file_url,
           enable_validation_caching,
           reply_msg))) {
     NotifyRendererOfError(nacl_host_message_filter.get(), reply_msg);
   }
 }
 
 }  // namespace nacl_file_host