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

chrome/service/service_utility_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 "chrome/service/service_utility_process_host.h"
 
 #include <stdint.h>
 
 #include <queue>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
@@ skipping 67 matching lines @@
  public:
   explicit PdfToEmfState(ServiceUtilityProcessHost* host)
       : host_(host), page_count_(0), current_page_(0), pages_in_progress_(0) {}
   ~PdfToEmfState() { Stop(); }
 
   bool Start(base::File pdf_file,
              const printing::PdfRenderSettings& conversion_settings) {
     if (!temp_dir_.CreateUniqueTempDir())
       return false;
     return host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
-        IPC::TakeFileHandleForProcess(pdf_file.Pass(), host_->handle()),
+        IPC::TakeFileHandleForProcess(std::move(pdf_file), host_->handle()),
         conversion_settings));
   }
 
   void GetMorePages() {
     const int kMaxNumberOfTempFilesPerDocument = 3;
     while (pages_in_progress_ < kMaxNumberOfTempFilesPerDocument &&
            current_page_ < page_count_) {
       ++pages_in_progress_;
       emf_files_.push(CreateTempFile());
       host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage(
@@ skipping 11 matching lines @@
     if (pages_in_progress_ || current_page_ < page_count_)
       return false;
     Stop();
     return true;
   }
 
   base::File TakeNextFile() {
     DCHECK(!emf_files_.empty());
     base::File file;
     if (!emf_files_.empty())
-      file = emf_files_.front().Pass();
+      file = std::move(emf_files_.front());
     emf_files_.pop();
-    return file.Pass();
+    return file;
   }
 
   void set_page_count(int page_count) { page_count_ = page_count; }
   bool has_page_count() { return page_count_ > 0; }
 
  private:
   void Stop() {
     host_->Send(new ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop());
   }
 
@@ skipping 38 matching lines @@
   ReportUmaEvent(SERVICE_UTILITY_METAFILE_REQUEST);
   start_time_ = base::Time::Now();
   base::File pdf_file(pdf_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!pdf_file.IsValid() || !StartProcess(false))
     return false;
 
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
 
   pdf_to_emf_state_.reset(new PdfToEmfState(this));
-  return pdf_to_emf_state_->Start(pdf_file.Pass(), render_settings);
+  return pdf_to_emf_state_->Start(std::move(pdf_file), render_settings);
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
   ReportUmaEvent(SERVICE_UTILITY_CAPS_REQUEST);
   start_time_ = base::Time::Now();
   if (!StartProcess(true))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
@@ skipping 228 matching lines @@
     return false;
   }
   printing::Emf emf;
   if (!emf.InitFromData(data.data(), data.size())) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   OnRenderPDFPagesToMetafilePageDone(scale_factor, emf);
   return true;
 }