Convert Pass()→std::move() on Windows

chrome/browser/printing/pdf_to_emf_converter.cc

 // Copyright 2014 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 "chrome/browser/printing/pdf_to_emf_converter.h"
 
 #include <stdint.h>
 
 #include <queue>
 #include <utility>
@@ skipping 46 matching lines @@
 typedef scoped_ptr<base::File, BrowserThread::DeleteOnFileThread>
     ScopedTempFile;
 
 // Wrapper for Emf to keep only file handle in memory, and load actual data only
 // on playback. Emf::InitFromFile() can play metafile directly from disk, but it
 // can't open file handles. We need file handles to reliably delete temporary
 // files, and to efficiently interact with utility process.
 class LazyEmf : public MetafilePlayer {
  public:
   LazyEmf(const scoped_refptr<RefCountedTempDir>& temp_dir, ScopedTempFile file)
-      : temp_dir_(temp_dir), file_(file.Pass()) {
+      : temp_dir_(temp_dir), file_(std::move(file)) {
     CHECK(file_);
   }
   ~LazyEmf() override { Close(); }
 
   bool SafePlayback(HDC hdc) const override;
   bool SaveTo(base::File* file) const override;
 
  private:
   void Close() const;
   bool LoadEmf(Emf* emf) const;
@@ skipping 54 matching lines @@
       page_number_ = rhs.page_number_;
       callback_ = rhs.callback_;
       emf_ = std::move(rhs.emf_);
       return *this;
     }
 
     int page_number() const { return page_number_; }
     const PdfToEmfConverter::GetPageCallback& callback() const {
       return callback_;
     }
-    ScopedTempFile TakeEmf() { return emf_.Pass(); }
-    void set_emf(ScopedTempFile emf) { emf_ = emf.Pass(); }
+    ScopedTempFile TakeEmf() { return std::move(emf_); }
+    void set_emf(ScopedTempFile emf) { emf_ = std::move(emf); }
 
    private:
     int page_number_;
     PdfToEmfConverter::GetPageCallback callback_;
     ScopedTempFile emf_;
   };
 
   ~PdfToEmfUtilityProcessHostClient() override;
 
   bool Send(IPC::Message* msg);
@@ skipping 50 matching lines @@
   base::WeakPtrFactory<PdfToEmfConverterImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PdfToEmfConverterImpl);
 };
 
 ScopedTempFile CreateTempFile(scoped_refptr<RefCountedTempDir>* temp_dir) {
   if (!temp_dir->get())
     *temp_dir = new RefCountedTempDir();
   ScopedTempFile file;
   if (!(*temp_dir)->IsValid())
-    return file.Pass();
+    return file;
   base::FilePath path;
   if (!base::CreateTemporaryFileInDir((*temp_dir)->GetPath(), &path)) {
     PLOG(ERROR) << "Failed to create file in "
                 << (*temp_dir)->GetPath().value();
-    return file.Pass();
+    return file;
   }
   file.reset(new base::File(path,
                             base::File::FLAG_CREATE_ALWAYS |
                             base::File::FLAG_WRITE |
                             base::File::FLAG_READ |
                             base::File::FLAG_DELETE_ON_CLOSE |
                             base::File::FLAG_TEMPORARY));
   if (!file->IsValid()) {
     PLOG(ERROR) << "Failed to create " << path.value();
     file.reset();
   }
-  return file.Pass();
+  return file;
 }
 
 ScopedTempFile CreateTempPdfFile(
     const scoped_refptr<base::RefCountedMemory>& data,
     scoped_refptr<RefCountedTempDir>* temp_dir) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   ScopedTempFile pdf_file = CreateTempFile(temp_dir);
   if (!pdf_file ||
       static_cast<int>(data->size()) !=
           pdf_file->WriteAtCurrentPos(data->front_as<char>(), data->size())) {
     pdf_file.reset();
-    return pdf_file.Pass();
+    return pdf_file;
   }
   pdf_file->Seek(base::File::FROM_BEGIN, 0);
-  return pdf_file.Pass();
+  return pdf_file;
 }
 
 bool LazyEmf::SafePlayback(HDC hdc) const {
   Emf emf;
   bool result = LoadEmf(&emf) && emf.SafePlayback(hdc);
   // TODO(vitalybuka): Fix destruction of metafiles. For some reasons
   // instances of Emf are not deleted. crbug.com/411683
   // It's known that the Emf going to be played just once to a printer. So just
   // release file here.
   Close();
@@ skipping 127 matching lines @@
 
 void PdfToEmfUtilityProcessHostClient::OnTempEmfReady(
     GetPageCallbackData* callback_data,
     ScopedTempFile emf) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!utility_process_host_ || !emf)
     return OnFailed();
   base::ProcessHandle process = utility_process_host_->GetData().handle;
   IPC::PlatformFileForTransit transit =
       IPC::GetFileHandleForProcess(emf->GetPlatformFile(), process, false);
-  callback_data->set_emf(emf.Pass());
+  callback_data->set_emf(std::move(emf));
   // Should reply with OnPageDone().
   Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
       callback_data->page_number(), transit));
 }
 
 void PdfToEmfUtilityProcessHostClient::OnPageDone(bool success,
                                                   float scale_factor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (get_page_callbacks_.empty())
     return OnFailed();
   GetPageCallbackData& data = get_page_callbacks_.front();
   scoped_ptr<MetafilePlayer> emf;
 
   if (success) {
     ScopedTempFile temp_emf = data.TakeEmf();
     if (!temp_emf)  // Unexpected message from utility process.
       return OnFailed();
-    emf.reset(new LazyEmf(temp_dir_, temp_emf.Pass()));
+    emf.reset(new LazyEmf(temp_dir_, std::move(temp_emf)));
   }
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&PdfToEmfConverterImpl::RunCallback,
                                      converter_,
                                      base::Bind(data.callback(),
                                                 data.page_number(),
                                                 scale_factor,
                                                 base::Passed(&emf))));
@@ skipping 81 matching lines @@
 
 PdfToEmfConverter::~PdfToEmfConverter() {
 }
 
 // static
 scoped_ptr<PdfToEmfConverter> PdfToEmfConverter::CreateDefault() {
   return scoped_ptr<PdfToEmfConverter>(new PdfToEmfConverterImpl());
 }
 
 }  // namespace printing