Clean up printing/emf_win.cc.

printing/emf_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/emf_win.h"
 
 #include <stdint.h>
 
+#include <algorithm>
 #include <memory>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/scoped_select_object.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
+namespace printing {
+
 namespace {
 
 int CALLBACK IsAlphaBlendUsedEnumProc(HDC,
                                       HANDLETABLE*,
                                       const ENHMETARECORD *record,
                                       int,
                                       LPARAM data) {
   bool* result = reinterpret_cast<bool*>(data);
   if (!result)
     return 0;
@@ skipping 53 matching lines @@
       // Play this command to the metafile DC.
       ::PlayEnhMetaFileRecord(metafile_dc, handle_table, record, num_objects);
       break;
     }
     return 1;  // Continue enumeration
 }
 
 // Bitmapt for rasterization.
 class RasterBitmap {
  public:
-  explicit RasterBitmap(const gfx::Size& raster_size)
-      : saved_object_(NULL) {
-    context_.Set(::CreateCompatibleDC(NULL));
+  explicit RasterBitmap(const gfx::Size& raster_size) : saved_object_(nullptr) {
+    context_.Set(::CreateCompatibleDC(nullptr));
     if (!context_.IsValid()) {
       NOTREACHED() << "Bitmap DC creation failed";
       return;
     }
     ::SetGraphicsMode(context_.Get(), GM_ADVANCED);
-    void* bits = NULL;
+    void* bits = nullptr;
     gfx::Rect bitmap_rect(raster_size);
     skia::CreateBitmapHeader(raster_size.width(), raster_size.height(),
                              &header_.bmiHeader);
     bitmap_.reset(CreateDIBSection(context_.Get(), &header_, DIB_RGB_COLORS,
-                                   &bits, NULL, 0));
+                                   &bits, nullptr, 0));
     if (!bitmap_.is_valid())
       NOTREACHED() << "Raster bitmap creation for printing failed";
 
     saved_object_ = ::SelectObject(context_.Get(), bitmap_.get());
     RECT rect = bitmap_rect.ToRECT();
     ::FillRect(context_.Get(), &rect,
                static_cast<HBRUSH>(::GetStockObject(WHITE_BRUSH)));
   }
 
   ~RasterBitmap() {
     ::SelectObject(context_.Get(), saved_object_);
   }
 
   HDC context() const {
     return context_.Get();
   }
 
   base::win::ScopedCreateDC context_;
   BITMAPINFO header_;
   base::win::ScopedBitmap bitmap_;
   HGDIOBJ saved_object_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RasterBitmap);
 };
 
-
-
-}  // namespace
-
-namespace printing {
-
 bool DIBFormatNativelySupported(HDC dc, uint32_t escape, const BYTE* bits,
                                 int size) {
   BOOL supported = FALSE;
   if (ExtEscape(dc, QUERYESCSUPPORT, sizeof(escape),
                 reinterpret_cast<LPCSTR>(&escape), 0, 0) > 0) {
     ExtEscape(dc, escape, size, reinterpret_cast<LPCSTR>(bits),
               sizeof(supported), reinterpret_cast<LPSTR>(&supported));
   }
   return !!supported;
 }
 
-Emf::Emf() : emf_(NULL), hdc_(NULL) {
-}
+}  // namespace
+
+Emf::Emf() : emf_(nullptr), hdc_(nullptr) {}
 
 Emf::~Emf() {
   Close();
 }
 
 void Emf::Close() {
   DCHECK(!hdc_);
   if (emf_)
     DeleteEnhMetaFile(emf_);
-  emf_ = NULL;
+  emf_ = nullptr;
 }
 
 bool Emf::InitToFile(const base::FilePath& metafile_path) {
   DCHECK(!emf_ && !hdc_);
-  hdc_ = CreateEnhMetaFile(NULL, metafile_path.value().c_str(), NULL, NULL);
+  hdc_ = CreateEnhMetaFile(nullptr, metafile_path.value().c_str(), nullptr,
+                           nullptr);
   DCHECK(hdc_);
-  return hdc_ != NULL;
+  return !!hdc_;
 }
 
 bool Emf::InitFromFile(const base::FilePath& metafile_path) {
   DCHECK(!emf_ && !hdc_);
   emf_ = GetEnhMetaFile(metafile_path.value().c_str());
   DCHECK(emf_);
-  return emf_ != NULL;
+  return !!emf_;
 }
 
 bool Emf::Init() {
   DCHECK(!emf_ && !hdc_);
-  hdc_ = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
+  hdc_ = CreateEnhMetaFile(nullptr, nullptr, nullptr, nullptr);
   DCHECK(hdc_);
-  return hdc_ != NULL;
+  return !!hdc_;
 }
 
 bool Emf::InitFromData(const void* src_buffer, uint32_t src_buffer_size) {
   DCHECK(!emf_ && !hdc_);
   emf_ = SetEnhMetaFileBits(src_buffer_size,
                             reinterpret_cast<const BYTE*>(src_buffer));
-  return emf_ != NULL;
+  return !!emf_;
 }
 
 bool Emf::FinishDocument() {
   DCHECK(!emf_ && hdc_);
   emf_ = CloseEnhMetaFile(hdc_);
   DCHECK(emf_);
-  hdc_ = NULL;
-  return emf_ != NULL;
+  hdc_ = nullptr;
+  return !!emf_;
 }
 
 bool Emf::Playback(HDC hdc, const RECT* rect) const {
   DCHECK(emf_ && !hdc_);
   RECT bounds;
   if (!rect) {
     // Get the natural bounds of the EMF buffer.
     bounds = GetPageBounds(1).ToRECT();
     rect = &bounds;
   }
@@ skipping 38 matching lines @@
 unsigned int Emf::GetPageCount() const {
   return 1;
 }
 
 HDC Emf::context() const {
   return hdc_;
 }
 
 uint32_t Emf::GetDataSize() const {
   DCHECK(emf_ && !hdc_);
-  return GetEnhMetaFileBits(emf_, 0, NULL);
+  return GetEnhMetaFileBits(emf_, 0, nullptr);
 }
 
 bool Emf::GetData(void* buffer, uint32_t size) const {
   DCHECK(emf_ && !hdc_);
   DCHECK(buffer && size);
   uint32_t size2 =
       GetEnhMetaFileBits(emf_, size, reinterpret_cast<BYTE*>(buffer));
   DCHECK(size2 == size);
   return size2 == size && size2 != 0;
 }
@@ skipping 71 matching lines @@
   // device.
   // TODO(sanjeevr): We should also add JPEG/PNG support for SetSIBitsToDevice
   //
   // We also process any custom EMR_GDICOMMENT records which are our
   // placeholders for StartPage and EndPage.
   // Note: I should probably care about view ports and clipping, eventually.
   bool res = false;
   const XFORM* base_matrix = context->base_matrix;
   switch (record()->iType) {
     case EMR_STRETCHDIBITS: {
-      const EMRSTRETCHDIBITS * sdib_record =
+      const EMRSTRETCHDIBITS* sdib_record =
           reinterpret_cast<const EMRSTRETCHDIBITS*>(record());
       const BYTE* record_start = reinterpret_cast<const BYTE *>(record());
-      const BITMAPINFOHEADER *bmih =
-          reinterpret_cast<const BITMAPINFOHEADER *>(record_start +
-                                                     sdib_record->offBmiSrc);
+      const BITMAPINFOHEADER* bmih = reinterpret_cast<const BITMAPINFOHEADER*>(
+          record_start + sdib_record->offBmiSrc);
       const BYTE* bits = record_start + sdib_record->offBitsSrc;
       bool play_normally = true;
       res = false;
       HDC hdc = context->hdc;
       std::unique_ptr<SkBitmap> bitmap;
       if (bmih->biCompression == BI_JPEG) {
         if (!DIBFormatNativelySupported(hdc, CHECKJPEGFORMAT, bits,
                                         bmih->biSizeImage)) {
           play_normally = false;
           bitmap = gfx::JPEGCodec::Decode(bits, bmih->biSizeImage);
         }
       } else if (bmih->biCompression == BI_PNG) {
         if (!DIBFormatNativelySupported(hdc, CHECKPNGFORMAT, bits,
                                         bmih->biSizeImage)) {
           play_normally = false;
-          bitmap.reset(new SkBitmap());
+          bitmap = base::MakeUnique<SkBitmap>();
           gfx::PNGCodec::Decode(bits, bmih->biSizeImage, bitmap.get());
         }
       }
-      if (!play_normally) {
+      if (play_normally) {
+        res = Play(context);
+      } else {
         DCHECK(bitmap.get());
         if (bitmap.get()) {
           SkAutoLockPixels lock(*bitmap.get());
           DCHECK_EQ(bitmap->colorType(), kN32_SkColorType);
           const uint32_t* pixels =
               static_cast<const uint32_t*>(bitmap->getPixels());
-          if (pixels == NULL) {
+          if (!pixels) {
             NOTREACHED();
             return false;
           }
           BITMAPINFOHEADER bmi = {0};
           skia::CreateBitmapHeader(bitmap->width(), bitmap->height(), &bmi);
           res = (0 != StretchDIBits(hdc, sdib_record->xDest, sdib_record->yDest,
                                     sdib_record->cxDest,
                                     sdib_record->cyDest, sdib_record->xSrc,
                                     sdib_record->ySrc,
                                     sdib_record->cxSrc, sdib_record->cySrc,
                                     pixels,
                                     reinterpret_cast<const BITMAPINFO *>(&bmi),
                                     sdib_record->iUsageSrc,
                                     sdib_record->dwRop));
         }
-      } else {
-        res = Play(context);
       }
       break;
     }
     case EMR_SETWORLDTRANSFORM: {
       DCHECK_EQ(record()->nSize, sizeof(DWORD) * 2 + sizeof(XFORM));
       const XFORM* xform = reinterpret_cast<const XFORM*>(record()->dParm);
       HDC hdc = context->hdc;
       if (base_matrix) {
         res = 0 != SetWorldTransform(hdc, base_matrix) &&
                    ModifyWorldTransform(hdc, xform, MWT_LEFTMULTIPLY);
@@ skipping 95 matching lines @@
     DCHECK_EQ(emf.context_.handle_table, handle_table);
     DCHECK_EQ(emf.context_.objects_count, objects_count);
     DCHECK_EQ(emf.context_.hdc, hdc);
   }
   emf.items_.push_back(Record(record));
   return 1;
 }
 
 bool Emf::IsAlphaBlendUsed() const {
   bool result = false;
-  ::EnumEnhMetaFile(NULL,
-                    emf(),
-                    &IsAlphaBlendUsedEnumProc,
-                    &result,
-                    NULL);
+  ::EnumEnhMetaFile(nullptr, emf(), &IsAlphaBlendUsedEnumProc, &result,
+                    nullptr);
   return result;
 }
 
 std::unique_ptr<Emf> Emf::RasterizeMetafile(int raster_area_in_pixels) const {
   gfx::Rect page_bounds = GetPageBounds(1);
   gfx::Size page_size(page_bounds.size());
   if (page_size.GetArea() <= 0) {
     NOTREACHED() << "Metafile is empty";
     page_bounds = gfx::Rect(1, 1);
   }
 
   float scale = sqrt(
       static_cast<float>(raster_area_in_pixels) / page_size.GetArea());
   page_size.set_width(std::max<int>(1, page_size.width() * scale));
   page_size.set_height(std::max<int>(1, page_size.height() * scale));
 
 
   RasterBitmap bitmap(page_size);
 
   gfx::Rect bitmap_rect(page_size);
   RECT rect = bitmap_rect.ToRECT();
   Playback(bitmap.context(), &rect);
 
-  std::unique_ptr<Emf> result(new Emf);
+  std::unique_ptr<Emf> result = base::MakeUnique<Emf>();
   result->Init();
   HDC hdc = result->context();
   DCHECK(hdc);
   skia::InitializeDC(hdc);
 
   // Params are ignored.
   result->StartPage(page_bounds.size(), page_bounds, 1);
 
-  ::ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
+  ::ModifyWorldTransform(hdc, nullptr, MWT_IDENTITY);
   XFORM xform = {
     static_cast<float>(page_bounds.width()) / bitmap_rect.width(),
     0,
     0,
     static_cast<float>(page_bounds.height()) / bitmap_rect.height(),
     static_cast<float>(page_bounds.x()),
     static_cast<float>(page_bounds.y()),
   };
   ::SetWorldTransform(hdc, &xform);
   ::BitBlt(hdc, 0, 0, bitmap_rect.width(), bitmap_rect.height(),
            bitmap.context(), bitmap_rect.x(), bitmap_rect.y(), SRCCOPY);
 
   result->FinishPage();
   result->FinishDocument();
-
   return result;
 }
 
 std::unique_ptr<Emf> Emf::RasterizeAlphaBlend() const {
   gfx::Rect page_bounds = GetPageBounds(1);
   if (page_bounds.size().GetArea() <= 0) {
     NOTREACHED() << "Metafile is empty";
     page_bounds = gfx::Rect(1, 1);
   }
 
   RasterBitmap bitmap(page_bounds.size());
 
   // Map metafile page_bounds.x(), page_bounds.y() to bitmap 0, 0.
   XFORM xform = {1,
                  0,
                  0,
                  1,
                  static_cast<float>(-page_bounds.x()),
                  static_cast<float>(-page_bounds.y())};
   ::SetWorldTransform(bitmap.context(), &xform);
 
-  std::unique_ptr<Emf> result(new Emf);
+  std::unique_ptr<Emf> result = base::MakeUnique<Emf>();
   result->Init();
   HDC hdc = result->context();
   DCHECK(hdc);
   skia::InitializeDC(hdc);
 
   HDC bitmap_dc = bitmap.context();
   RECT rect = page_bounds.ToRECT();
   ::EnumEnhMetaFile(hdc, emf(), &RasterizeAlphaBlendProc, &bitmap_dc, &rect);
 
   result->FinishDocument();
-
   return result;
 }
 
-
 }  // namespace printing