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

components/nacl/browser/pnacl_host.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/browser/pnacl_host.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/pnacl_translation_cache.h"
@@ skipping 26 matching lines @@
   int Write(scoped_refptr<net::DrainableIOBuffer> buffer);
   void WriteDone(const PnaclHost::TranslationID& id, int result);
 
  private:
   scoped_ptr<base::File> file_;
   base::WeakPtr<pnacl::PnaclHost> host_;
 };
 
 FileProxy::FileProxy(scoped_ptr<base::File> file,
                      base::WeakPtr<pnacl::PnaclHost> host)
-    : file_(file.Pass()),
-      host_(host) {
-}
+    : file_(std::move(file)), host_(host) {}
 
 int FileProxy::Write(scoped_refptr<net::DrainableIOBuffer> buffer) {
   int rv = file_->Write(0, buffer->data(), buffer->size());
   if (rv == -1)
     PLOG(ERROR) << "FileProxy::Write error";
   return rv;
 }
 
 void FileProxy::WriteDone(const PnaclHost::TranslationID& id, int result) {
   if (host_) {
-    host_->OnBufferCopiedToTempFile(id, file_.Pass(), result);
+    host_->OnBufferCopiedToTempFile(id, std::move(file_), result);
   } else {
     BrowserThread::PostBlockingPoolTask(
         FROM_HERE,
         base::Bind(CloseScopedFile, Passed(&file_)));
   }
 }
 
 PnaclHost::PnaclHost()
     : pending_backend_operations_(0),
       cache_state_(CacheUninitialized),
@@ skipping 123 matching lines @@
   } else {
     file.Initialize(
         file_path,
         base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_READ |
             base::File::FLAG_WRITE | base::File::FLAG_TEMPORARY |
             base::File::FLAG_DELETE_ON_CLOSE);
 
     if (!file.IsValid())
       PLOG(ERROR) << "Temp file open failed: " << file.error_details();
   }
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(cb, Passed(file.Pass())));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(cb, Passed(std::move(file))));
 }
 
 void PnaclHost::CreateTemporaryFile(TempFileCallback cb) {
   if (!BrowserThread::PostBlockingPoolSequencedTask(
            "PnaclHostCreateTempFile",
            FROM_HERE,
            base::Bind(&PnaclHost::DoCreateTemporaryFile, temp_dir_, cb))) {
     DCHECK(thread_checker_.CalledOnValidThread());
     cb.Run(base::File());
   }
@@ skipping 102 matching lines @@
 // could be cancelled before they get called).
 void PnaclHost::OnTempFileReturn(const TranslationID& id,
                                  base::File file) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PendingTranslationMap::iterator entry(pending_translations_.find(id));
   if (entry == pending_translations_.end()) {
     // The renderer may have signaled an error or closed while the temp
     // file was being created.
     LOG(ERROR) << "OnTempFileReturn: id not found";
     BrowserThread::PostBlockingPoolTask(
-        FROM_HERE, base::Bind(CloseBaseFile, Passed(file.Pass())));
+        FROM_HERE, base::Bind(CloseBaseFile, Passed(std::move(file))));
     return;
   }
   if (!file.IsValid()) {
     // This translation will fail, but we need to retry any translation
     // waiting for its result.
     LOG(ERROR) << "OnTempFileReturn: temp file creation failed";
     std::string key(entry->second.cache_key);
     entry->second.callback.Run(base::File(), false);
     bool may_be_cached = TranslationMayBeCached(entry);
     pending_translations_.erase(entry);
     // No translations will be waiting for entries that will not be stored.
     if (may_be_cached)
       RequeryMatchingTranslations(key);
     return;
   }
   PendingTranslation* pt = &entry->second;
   pt->got_nexe_fd = true;
-  pt->nexe_fd = new base::File(file.Pass());
+  pt->nexe_fd = new base::File(std::move(file));
   CheckCacheQueryReady(entry);
 }
 
 // Check whether both the cache query and the temp file have returned, and check
 // whether we actually got a hit or not.
 void PnaclHost::CheckCacheQueryReady(
     const PendingTranslationMap::iterator& entry) {
   PendingTranslation* pt = &entry->second;
   if (!(pt->got_cache_reply && pt->got_nexe_fd))
     return;
@@ skipping 15 matching lines @@
         return;
       }
     }
     ReturnMiss(entry);
     return;
   }
 
   scoped_ptr<base::File> file(pt->nexe_fd);
   pt->nexe_fd = NULL;
   pt->got_nexe_fd = false;
-  FileProxy* proxy(new FileProxy(file.Pass(), weak_factory_.GetWeakPtr()));
+  FileProxy* proxy(new FileProxy(std::move(file), weak_factory_.GetWeakPtr()));
 
   if (!base::PostTaskAndReplyWithResult(
            BrowserThread::GetBlockingPool(),
            FROM_HERE,
            base::Bind(&FileProxy::Write, base::Unretained(proxy),
                       pt->nexe_read_buffer),
            base::Bind(&FileProxy::WriteDone, base::Owned(proxy),
                       entry->first))) {
     pt->callback.Run(base::File(), false);
   }
@@ skipping 287 matching lines @@
   DCHECK(pending_backend_operations_ >= 0);
   if (pending_translations_.empty() &&
       pending_backend_operations_ <= 0 &&
       cache_state_ == CacheReady) {
     cache_state_ = CacheUninitialized;
     disk_cache_.reset();
   }
 }
 
 }  // namespace pnacl