Convert Pass()→std::move() in //chrome/browser/ui

chrome/browser/ui/webui/print_preview/extension_printer_handler.cc

 // Copyright 2015 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/ui/webui/print_preview/extension_printer_handler.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/string_split.h"
@@ skipping 37 matching lines @@
 
 const char kProvisionalUsbLabel[] = "provisional-usb";
 
 // Updates |job| with raster file path, size and last modification time.
 // Returns the updated print job.
 scoped_ptr<extensions::PrinterProviderPrintJob> UpdateJobFileInfoOnWorkerThread(
     const base::FilePath& raster_path,
     scoped_ptr<extensions::PrinterProviderPrintJob> job) {
   if (base::GetFileInfo(raster_path, &job->file_info))
     job->document_path = raster_path;
-  return job.Pass();
+  return job;
 }
 
 // Callback to PWG raster conversion.
 // Posts a task to update print job with info about file containing converted
 // PWG raster data. The task is posted to |slow_task_runner|.
 void UpdateJobFileInfo(
     scoped_ptr<extensions::PrinterProviderPrintJob> job,
     const scoped_refptr<base::TaskRunner>& slow_task_runner,
     const ExtensionPrinterHandler::PrintJobCallback& callback,
     bool success,
     const base::FilePath& pwg_file_path) {
   if (!success) {
-    callback.Run(job.Pass());
+    callback.Run(std::move(job));
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       slow_task_runner.get(), FROM_HERE,
       base::Bind(&UpdateJobFileInfoOnWorkerThread, pwg_file_path,
                  base::Passed(&job)),
       callback);
 }
 
@@ skipping 111 matching lines @@
   content_types.LoadFrom(printer_description);
 
   const bool kUsePdf = content_types.Contains(kContentTypePdf) ||
                        content_types.Contains(kContentTypeAll);
 
   if (kUsePdf) {
     // TODO(tbarzic): Consider writing larger PDF to disk and provide the data
     // the same way as it's done with PWG raster.
     print_job->content_type = kContentTypePdf;
     print_job->document_bytes = print_data;
-    DispatchPrintJob(callback, print_job.Pass());
+    DispatchPrintJob(callback, std::move(print_job));
     return;
   }
 
   cloud_devices::CloudDeviceDescription ticket;
   if (!ticket.InitFromString(ticket_json)) {
     WrapPrintCallback(callback, false, kInvalidTicketPrintError);
     return;
   }
 
   print_job->content_type = kContentTypePWGRaster;
   ConvertToPWGRaster(print_data, printer_description, ticket, page_size,
-                     print_job.Pass(),
+                     std::move(print_job),
                      base::Bind(&ExtensionPrinterHandler::DispatchPrintJob,
                                 weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ExtensionPrinterHandler::StartGrantPrinterAccess(
     const std::string& printer_id,
     const PrinterHandler::GetPrinterInfoCallback& callback) {
   std::string extension_id;
   std::string device_guid;
   if (!ParseProvisionalUsbPrinterId(printer_id, &extension_id, &device_guid)) {
@@ skipping 15 matching lines @@
   extensions::PrinterProviderAPIFactory::GetInstance()
       ->GetForBrowserContext(browser_context_)
       ->DispatchGetUsbPrinterInfoRequested(
           extension_id, device,
           base::Bind(&ExtensionPrinterHandler::WrapGetPrinterInfoCallback,
                      weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ExtensionPrinterHandler::SetPwgRasterConverterForTesting(
     scoped_ptr<local_discovery::PWGRasterConverter> pwg_raster_converter) {
-  pwg_raster_converter_ = pwg_raster_converter.Pass();
+  pwg_raster_converter_ = std::move(pwg_raster_converter);
 }
 
 void ExtensionPrinterHandler::ConvertToPWGRaster(
     const scoped_refptr<base::RefCountedMemory>& data,
     const cloud_devices::CloudDeviceDescription& printer_description,
     const cloud_devices::CloudDeviceDescription& ticket,
     const gfx::Size& page_size,
     scoped_ptr<extensions::PrinterProviderPrintJob> job,
     const ExtensionPrinterHandler::PrintJobCallback& callback) {
   if (!pwg_raster_converter_) {
@@ skipping 95 matching lines @@
                 .Set("extensionName", extension->name())
                 .Set("provisional", true)));
       }
     }
   }
 
   DCHECK_GT(pending_enumeration_count_, 0);
   pending_enumeration_count_--;
   callback.Run(*printer_list.Build().get(), pending_enumeration_count_ == 0);
 }