Consolidate Windows bitmap and DC code

ui/native_theme/native_theme_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 "ui/native_theme/native_theme_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
 #include <vssym32.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/scoped_select_object.h"
 #include "base/win/windows_version.h"
-#include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkShader.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/win/dpi.h"
 #include "ui/native_theme/common_theme.h"
 
 // This was removed from Winvers.h but is still used.
@@ skipping 248 matching lines @@
       case kScrollbarHorizontalGripper:
       case kScrollbarVerticalGripper:
         needs_paint_indirect = !GetThemeHandle(SCROLLBAR) ||
             base::win::GetVersion() == base::win::VERSION_XP;
         break;
       default:
         break;
     }
   }
 
+  skia::ScopedPlatformPaint paint(canvas);
+  HDC surface = paint.GetPlatformSurface();
   if (needs_paint_indirect)
-    PaintIndirect(canvas, part, state, rect, extra);
+    PaintIndirect(surface, part, state, rect, extra);
   else
-    PaintDirect(canvas, part, state, rect, extra);
+    PaintDirect(surface, part, state, rect, extra);
 }
 
 NativeThemeWin::NativeThemeWin()
     : draw_theme_(NULL),
       draw_theme_ex_(NULL),
       get_theme_color_(NULL),
       get_theme_content_rect_(NULL),
       get_theme_part_size_(NULL),
       open_theme_(NULL),
       close_theme_(NULL),
@@ skipping 45 matching lines @@
   UpdateSystemColors();
   is_using_high_contrast_valid_ = false;
   NotifyObservers();
 }
 
 void NativeThemeWin::UpdateSystemColors() {
   for (int kSystemColor : kSystemColors)
     system_colors_[kSystemColor] = color_utils::GetSysSkColor(kSystemColor);
 }
 
-void NativeThemeWin::PaintDirect(SkCanvas* canvas,
+void NativeThemeWin::PaintDirect(HDC hdc,
                                  Part part,
                                  State state,
                                  const gfx::Rect& rect,
                                  const ExtraParams& extra) const {
-  skia::ScopedPlatformPaint scoped_platform_paint(canvas);
-  HDC hdc = scoped_platform_paint.GetPlatformSurface();
-
   switch (part) {
     case kCheckbox:
       PaintCheckbox(hdc, part, state, rect, extra.button);
       return;
     case kInnerSpinButton:
       PaintSpinButton(hdc, part, state, rect, extra.inner_spin);
       return;
     case kMenuList:
       PaintMenuList(hdc, state, rect, extra.menu_list);
       return;
@@ skipping 34 matching lines @@
       PaintScrollbarArrow(hdc, part, state, rect, extra.scrollbar_arrow);
       return;
     case kScrollbarHorizontalThumb:
     case kScrollbarVerticalThumb:
     case kScrollbarHorizontalGripper:
     case kScrollbarVerticalGripper:
       PaintScrollbarThumb(hdc, part, state, rect, extra.scrollbar_thumb);
       return;
     case kScrollbarHorizontalTrack:
     case kScrollbarVerticalTrack:
-      PaintScrollbarTrack(canvas, hdc, part, state, rect,
-                          extra.scrollbar_track);
+      PaintScrollbarTrack(hdc, part, state, rect, extra.scrollbar_track);
       return;
-    case kScrollbarCorner:
-      canvas->drawColor(SK_ColorWHITE, SkXfermode::kSrc_Mode);
+    case kScrollbarCorner: {
+      SkSurface* surface = skia::MapPlatformSurface(hdc);
+      SkCanvas* canvas = surface ? surface->getCanvas() : nullptr;
+      if (canvas)
+        canvas->drawColor(SK_ColorWHITE, SkXfermode::kSrc_Mode);
       return;
+    }
     case kTabPanelBackground:
       PaintTabPanelBackground(hdc, rect);
       return;
     case kTextField:
       PaintTextField(hdc, part, state, rect, extra.text_field);
       return;
     case kTrackbarThumb:
     case kTrackbarTrack:
-      PaintTrackbar(canvas, hdc, part, state, rect, extra.trackbar);
+      PaintTrackbar(hdc, part, state, rect, extra.trackbar);
       return;
     case kWindowResizeGripper:
       PaintWindowResizeGripper(hdc, rect);
       return;
     case kComboboxArrow:
     case kSliderTrack:
     case kSliderThumb:
     case kMaxPart:
       NOTREACHED();
   }
@@ skipping 193 matching lines @@
       case NativeTheme::kColorId_CallToActionColor:
         return kCallToActionColorInvert;
       default:
         return color_utils::InvertColor(GetAuraColor(color_id, this));
     }
   }
 
   return GetAuraColor(color_id, this);
 }
 
-void NativeThemeWin::PaintIndirect(SkCanvas* canvas,
+void NativeThemeWin::PaintIndirect(HDC hdc,
                                    Part part,
                                    State state,
                                    const gfx::Rect& rect,
                                    const ExtraParams& extra) const {
   // TODO(asvitkine): This path is pretty inefficient - for each paint operation
   //                  it creates a new offscreen bitmap Skia canvas. This can
   //                  be sped up by doing it only once per part/state and
   //                  keeping a cache of the resulting bitmaps.
 
   // Create an offscreen canvas that is backed by an HDC.
-  skia::RefPtr<skia::BitmapPlatformDevice> device = skia::AdoptRef(
-      skia::BitmapPlatformDevice::Create(
-          rect.width(), rect.height(), false, NULL));
-  DCHECK(device);
-  SkCanvas offscreen_canvas(device.get());
-  DCHECK(skia::SupportsPlatformPaint(&offscreen_canvas));
+
+  HDC offscreen_hdc = skia::CreateOffscreenSurface(rect.width(), rect.height());

[Peter Kasting, 2016/02/16 21:12:10]

Nit: Use ScopedCreateDC here instead of a raw HDC to ensure proper cleanup. 
This avoids the need for the direct DeleteDC() call.

[tomhudson, 2016/06/21 22:20:23]

Done.

+  SkSurface* offscreen_surface = skia::MapPlatformSurface(offscreen_hdc);
+  DCHECK(offscreen_surface);
+  SkCanvas* offscreen_canvas = offscreen_surface->getCanvas();
+  DCHECK(offscreen_canvas);
 
   // Some of the Windows theme drawing operations do not write correct alpha
   // values for fully-opaque pixels; instead the pixels get alpha 0. This is
   // especially a problem on Windows XP or when using the Classic theme.
   //
   // To work-around this, mark all pixels with a placeholder value, to detect
   // which pixels get touched by the paint operation. After paint, set any
   // pixels that have alpha 0 to opaque and placeholders to fully-transparent.
   const SkColor placeholder = SkColorSetARGB(1, 0, 0, 0);
-  offscreen_canvas.clear(placeholder);
+  offscreen_canvas->clear(placeholder);
 
   // Offset destination rects to have origin (0,0).
   gfx::Rect adjusted_rect(rect.size());
   ExtraParams adjusted_extra(extra);
   switch (part) {
     case kProgressBar:
       adjusted_extra.progress_bar.value_rect_x = 0;
       adjusted_extra.progress_bar.value_rect_y = 0;
       break;
     case kScrollbarHorizontalTrack:
     case kScrollbarVerticalTrack:
       adjusted_extra.scrollbar_track.track_x = 0;
       adjusted_extra.scrollbar_track.track_y = 0;
       break;
     default:
       break;
   }
+
   // Draw the theme controls using existing HDC-drawing code.
-  PaintDirect(&offscreen_canvas, part, state, adjusted_rect, adjusted_extra);
-
-  // Copy the pixels to a bitmap that has ref-counted pixel storage, which is
-  // necessary to have when drawing to a SkPicture.
-  const SkBitmap& hdc_bitmap =
-      offscreen_canvas.getDevice()->accessBitmap(false);
-  SkBitmap bitmap;
-  hdc_bitmap.copyTo(&bitmap, kN32_SkColorType);
+  PaintDirect(offscreen_hdc, part, state, adjusted_rect, adjusted_extra);
 
   // Post-process the pixels to fix up the alpha values (see big comment above).
+  SkBitmap offscreen_bitmap = skia::MapPlatformBitmap(offscreen_hdc);
   const SkPMColor placeholder_value = SkPreMultiplyColor(placeholder);
   const int pixel_count = rect.width() * rect.height();
-  SkPMColor* pixels = bitmap.getAddr32(0, 0);
+  SkPMColor* pixels = offscreen_bitmap.getAddr32(0, 0);
   for (int i = 0; i < pixel_count; i++) {
     if (pixels[i] == placeholder_value) {
       // Pixel wasn't touched - make it fully transparent.
       pixels[i] = SkPackARGB32(0, 0, 0, 0);
     } else if (SkGetPackedA32(pixels[i]) == 0) {
       // Pixel was touched but has incorrect alpha of 0, make it fully opaque.
       pixels[i] = SkPackARGB32(0xFF,
                                SkGetPackedR32(pixels[i]),
                                SkGetPackedG32(pixels[i]),
                                SkGetPackedB32(pixels[i]));
     }
   }
 
-  // Draw the offscreen bitmap to the destination canvas.
-  canvas->drawBitmap(bitmap, rect.x(), rect.y());
+  SkSurface* destination_surface = skia::MapPlatformSurface(hdc);
+  DCHECK(destination_surface);
+  SkCanvas* destination_canvas = destination_surface->getCanvas();
+  DCHECK(destination_canvas);
+  destination_canvas->drawBitmap(offscreen_bitmap, rect.x(), rect.y());
+
+  DeleteDC(offscreen_hdc);
 }
 
 HRESULT NativeThemeWin::GetThemePartSize(ThemeName theme_name,
                                          HDC hdc,
                                          int part_id,
                                          int state_id,
                                          RECT* rect,
                                          int ts,
                                          SIZE* size) const {
   HANDLE handle = GetThemeHandle(theme_name);
@@ skipping 496 matching lines @@
     return PaintScaledTheme(handle, hdc, part_id, state_id, rect);
 
   // Draw it manually.
   if ((part_id == SBP_THUMBBTNHORZ) || (part_id == SBP_THUMBBTNVERT))
     DrawEdge(hdc, &rect_win, EDGE_RAISED, BF_RECT | BF_MIDDLE);
   // Classic mode doesn't have a gripper.
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintScrollbarTrack(
-    SkCanvas* canvas,
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const ScrollbarTrackExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(SCROLLBAR);
   RECT rect_win = rect.ToRECT();
 
   const int part_id = extra.is_upper ?
       ((part == kScrollbarHorizontalTrack) ?
@@ skipping 20 matching lines @@
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
 
   // Draw it manually.
   if ((system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_3DFACE]) &&
       (system_colors_[COLOR_SCROLLBAR] != system_colors_[COLOR_WINDOW])) {
     FillRect(hdc, &rect_win, reinterpret_cast<HBRUSH>(COLOR_SCROLLBAR + 1));
   } else {
+    SkSurface* surface = skia::MapPlatformSurface(hdc);
+    SkCanvas* canvas = surface ? surface->getCanvas() : nullptr;
+    if (!canvas)
+      return E_FAIL;
     SkPaint paint;
     RECT align_rect = gfx::Rect(extra.track_x, extra.track_y, extra.track_width,
                                 extra.track_height).ToRECT();
     SetCheckerboardShader(&paint, align_rect);
     canvas->drawIRect(skia::RECTToSkIRect(rect_win), paint);
   }
   if (extra.classic_state & DFCS_PUSHED)
     InvertRect(hdc, &rect_win);
   return S_OK;
 }
@@ skipping 25 matching lines @@
       break;
   }
 
   if (handle && draw_theme_)
     return draw_theme_(handle, hdc, part_id, state_id, &rect_win, NULL);
   DrawFrameControl(hdc, &rect_win, DFC_SCROLL, extra.classic_state);
   return S_OK;
 }
 
 HRESULT NativeThemeWin::PaintTrackbar(
-    SkCanvas* canvas,
     HDC hdc,
     Part part,
     State state,
     const gfx::Rect& rect,
     const TrackbarExtraParams& extra) const {
   const int part_id = extra.vertical ?
       ((part == kTrackbarTrack) ? TKP_TRACKVERT : TKP_THUMBVERT) :
       ((part == kTrackbarTrack) ? TKP_TRACK : TKP_THUMBBOTTOM);
 
   int state_id = TUS_NORMAL;
@@ skipping 53 matching lines @@
     RECT right_half = bottom_section;
     right_half.left += ((bottom_section.right - bottom_section.left) / 2);
     left_half.right = right_half.left;
     DrawEdge(hdc, &left_half, EDGE_RAISED,
              BF_DIAGONAL_ENDTOPLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
     DrawEdge(hdc, &right_half, EDGE_RAISED,
              BF_DIAGONAL_ENDBOTTOMLEFT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
 
     // If the button is pressed, draw hatching.
     if (extra.classic_state & DFCS_PUSHED) {
+      SkSurface* surface = skia::MapPlatformSurface(hdc);
+      SkCanvas* canvas = surface ? surface->getCanvas() : nullptr;
+      if (!canvas)
+        return E_FAIL;
       SkPaint paint;
       SetCheckerboardShader(&paint, rect_win);
 
       // Fill all three pieces with the pattern.
       canvas->drawIRect(skia::RECTToSkIRect(top_section), paint);
 
       SkScalar left_triangle_top = SkIntToScalar(left_half.top);
       SkScalar left_triangle_right = SkIntToScalar(left_half.right);
       SkPath left_triangle;
       left_triangle.moveTo(SkIntToScalar(left_half.left), left_triangle_top);
@@ skipping 653 matching lines @@
     break;
   case LAST:
     NOTREACHED();
     break;
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
 }  // namespace ui