Clean up printing/emf_win.cc.

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 <vector>
 
 #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"
@@ skipping 17 matching lines @@
 // static
 std::unique_ptr<PrintingContext> PrintingContext::Create(Delegate* delegate) {
 #if defined(ENABLE_BASIC_PRINTING)
   return base::WrapUnique(new PrintingContextSystemDialogWin(delegate));
 #else
   return base::WrapUnique(new PrintingContextWin(delegate));
 #endif
 }
 
 PrintingContextWin::PrintingContextWin(Delegate* delegate)
-    : PrintingContext(delegate), context_(NULL) {
-}
+    : PrintingContext(delegate), context_(nullptr) {}
 
 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);
+  scoped_refptr<PrintBackend> backend = PrintBackend::CreateInstance(nullptr);
   base::string16 default_printer =
       base::UTF8ToWide(backend->GetDefaultPrinterName());
   if (!default_printer.empty()) {
     ScopedPrinterHandle printer;
     if (printer.OpenPrinter(default_printer.c_str())) {
       std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
-          CreateDevMode(printer.Get(), NULL);
+          CreateDevMode(printer.Get(), nullptr);
       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);
+  (void)::EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr,
+                       2, nullptr, 0, &bytes_needed, &count_returned);
   if (bytes_needed) {
     DCHECK_GE(bytes_needed, count_returned * sizeof(PRINTER_INFO_2));
-    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);
+    std::vector<BYTE> printer_info_buffer(bytes_needed);
+    BOOL ret = ::EnumPrinters(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS,
+                              nullptr, 2, printer_info_buffer.data(),
+                              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());
+          reinterpret_cast<PRINTER_INFO_2*>(printer_info_buffer.data());
       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;
         std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
-            CreateDevMode(printer.Get(), NULL);
+            CreateDevMode(printer.Get(), nullptr);
         if (InitializeSettings(info_2->pPrinterName, dev_mode.get()) == OK)
           return OK;
       }
       if (context_)
         return OK;
     }
   }
 
   return OnError();
 }
@@ skipping 111 matching lines @@
   DCHECK(!in_print_job_);
 
   settings_ = settings;
 
   // TODO(maruel): settings_.ToDEVMODE()
   ScopedPrinterHandle printer;
   if (!printer.OpenPrinter(settings_.device_name().c_str()))
     return FAILED;
 
   std::unique_ptr<DEVMODE, base::FreeDeleter> dev_mode =
-      CreateDevMode(printer.Get(), NULL);
+      CreateDevMode(printer.Get(), nullptr);
 
   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 70 matching lines @@
 void PrintingContextWin::Cancel() {
   abort_printing_ = true;
   in_print_job_ = false;
   if (context_)
     CancelDC(context_);
 }
 
 void PrintingContextWin::ReleaseContext() {
   if (context_) {
     DeleteDC(context_);
-    context_ = NULL;
+    context_ = nullptr;
   }
 }
 
 gfx::NativeDrawingContext PrintingContextWin::context() const {
   return context_;
 }
 
 // static
 BOOL PrintingContextWin::AbortProc(HDC hdc, int nCode) {
   if (nCode) {
     // TODO(maruel):  Need a way to find the right instance to set. Should
     // leverage PrintJobManager here?
     // abort_printing_ = true;
   }
   return true;
 }
 
 PrintingContext::Result PrintingContextWin::InitializeSettings(
     const std::wstring& device_name,
     DEVMODE* dev_mode) {
   if (!dev_mode)
     return OnError();
 
   ReleaseContext();
-  context_ = CreateDC(L"WINSPOOL", device_name.c_str(), NULL, dev_mode);
+  context_ = CreateDC(L"WINSPOOL", device_name.c_str(), nullptr, dev_mode);
   if (!context_)
     return OnError();
 
   skia::InitializeDC(context_);
 
   DCHECK(!in_print_job_);
   settings_.set_device_name(device_name);
   PrintSettingsInitializerWin::InitPrintSettings(
       context_, *dev_mode, &settings_);
 
   return OK;
 }
 
 HWND PrintingContextWin::GetRootWindow(gfx::NativeView view) {
-  HWND window = NULL;
+  HWND window = nullptr;
   if (view && view->GetHost())
     window = view->GetHost()->GetAcceleratedWidget();
   if (!window) {
-    // TODO(maruel):  crbug.com/1214347 Get the right browser window instead.
+    // TODO(maruel):  b/1214347 Get the right browser window instead.

[dcheng, 2016/09/30 02:38:40]

Hmm...

[Lei Zhang, 2016/09/30 04:16:40]

Mmmhmm.

     return GetDesktopWindow();
   }
   return window;
 }
 
 }  // namespace printing