Convert //printing to use std::unique_ptr

printing/printing_context_win.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 "printing/printing_context_win.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/free_deleter.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "printing/backend/print_backend.h"
 #include "printing/backend/win_helper.h"
 #include "printing/print_settings_initializer_win.h"
 #include "printing/printed_document.h"
 #include "printing/printing_context_system_dialog_win.h"
 #include "printing/printing_utils.h"
 #include "printing/units.h"
 #include "skia/ext/skia_utils_win.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 
 namespace printing {
 
 namespace {
 
 void AssingResult(PrintingContext::Result* out, PrintingContext::Result in) {
   *out = in;
 }
 
 }  // namespace
 
 // static
-scoped_ptr<PrintingContext> PrintingContext::Create(Delegate* delegate) {
+std::unique_ptr<PrintingContext> PrintingContext::Create(Delegate* delegate) {
 #if defined(ENABLE_BASIC_PRINTING)
-  return make_scoped_ptr<PrintingContext>(
-      new PrintingContextSytemDialogWin(delegate));
+  return base::WrapUnique(new PrintingContextSytemDialogWin(delegate));
 #else   // ENABLE_BASIC_PRINTING
-  return make_scoped_ptr<PrintingContext>(new PrintingContextWin(delegate));
+  return base::WrapUnique(new PrintingContextWin(delegate));
 #endif  // EENABLE_BASIC_PRINTING
 }
 
 PrintingContextWin::PrintingContextWin(Delegate* delegate)
     : PrintingContext(delegate), context_(NULL) {
 }
 
 PrintingContextWin::~PrintingContextWin() {
   ReleaseContext();
 }
 
 void PrintingContextWin::AskUserForSettings(
     int max_pages,
     bool has_selection,
     bool is_scripted,
     const PrintSettingsCallback& callback) {
   NOTIMPLEMENTED();
 }
 
 PrintingContext::Result PrintingContextWin::UseDefaultSettings() {
   DCHECK(!in_print_job_);
 
   scoped_refptr<PrintBackend> backend = PrintBackend::CreateInstance(NULL);
   base::string16 default_printer =
       base::UTF8ToWide(backend->GetDefaultPrinterName());
   if (!default_printer.empty()) {
     ScopedPrinterHandle printer;
     if (printer.OpenPrinter(default_printer.c_str())) {
-      scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
+      std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
           CreateDevMode(printer.Get(), NULL);
       if (InitializeSettings(default_printer, dev_mode.get()) == OK)
         return OK;
     }
   }
 
   ReleaseContext();
 
   // No default printer configured, do we have any printers at all?
   DWORD bytes_needed = 0;
   DWORD count_returned = 0;
   (void)::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
                        NULL, 2, NULL, 0, &bytes_needed, &count_returned);
   if (bytes_needed) {
     DCHECK_GE(bytes_needed, count_returned * sizeof(PRINTER_INFO_2));
-    scoped_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]);
+    std::unique_ptr<BYTE[]> printer_info_buffer(new BYTE[bytes_needed]);
     BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL|PRINTER_ENUM_CONNECTIONS,
                               NULL, 2, printer_info_buffer.get(),
                               bytes_needed, &bytes_needed,
                               &count_returned);
     if (ret && count_returned) {  // have printers
       // Open the first successfully found printer.
       const PRINTER_INFO_2* info_2 =
           reinterpret_cast<PRINTER_INFO_2*>(printer_info_buffer.get());
       const PRINTER_INFO_2* info_2_end = info_2 + count_returned;
       for (; info_2 < info_2_end; ++info_2) {
         ScopedPrinterHandle printer;
         if (!printer.OpenPrinter(info_2->pPrinterName))
           continue;
-        scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
+        std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
             CreateDevMode(printer.Get(), NULL);
         if (InitializeSettings(info_2->pPrinterName, dev_mode.get()) == OK)
           return OK;
       }
       if (context_)
         return OK;
     }
   }
 
   return OnError();
@@ skipping 35 matching lines @@
     int page_count) {
   DCHECK(!in_print_job_);
   DCHECK(!external_preview) << "Not implemented";
 
   ScopedPrinterHandle printer;
   if (!printer.OpenPrinter(settings_.device_name().c_str()))
     return OnError();
 
   // Make printer changes local to Chrome.
   // See MSDN documentation regarding DocumentProperties.
-  scoped_ptr<DEVMODE, base::FreeDeleter> scoped_dev_mode =
+  std::unique_ptr<DEVMODE, base::FreeDeleter> scoped_dev_mode =
       CreateDevModeWithColor(printer.Get(), settings_.device_name(),
                              settings_.color() != GRAY);
   if (!scoped_dev_mode)
     return OnError();
 
   {
     DEVMODE* dev_mode = scoped_dev_mode.get();
     dev_mode->dmCopies = std::max(settings_.copies(), 1);
     if (dev_mode->dmCopies > 1) {  // do not change unless multiple copies
       dev_mode->dmFields |= DM_COPIES;
@@ skipping 56 matching lines @@
     const PrintSettings& settings) {
   DCHECK(!in_print_job_);
 
   settings_ = settings;
 
   // TODO(maruel): settings_.ToDEVMODE()
   ScopedPrinterHandle printer;
   if (!printer.OpenPrinter(settings_.device_name().c_str()))
     return FAILED;
 
-  scoped_ptr<DEVMODE, base::FreeDeleter> dev_mode =
+  std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
       CreateDevMode(printer.Get(), NULL);
 
   return InitializeSettings(settings_.device_name(), dev_mode.get());
 }
 
 PrintingContext::Result PrintingContextWin::NewDocument(
     const base::string16& document_name) {
   DCHECK(!in_print_job_);
   if (!context_)
     return OnError();
@@ skipping 122 matching lines @@
   if (view && view->GetHost())
     window = view->GetHost()->GetAcceleratedWidget();
   if (!window) {
     // TODO(maruel):  crbug.com/1214347 Get the right browser window instead.
     return GetDesktopWindow();
   }
   return window;
 }
 
 }  // namespace printing