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/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/SkRefCnt.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/display/win/dpi.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/skia_util.h"
 #include "ui/native_theme/common_theme.h"
 
@@ skipping 240 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 68 matching lines @@
   canvas->drawLine(position_x, rect.y(), position_x, rect.bottom(), paint);
 }
 
 void NativeThemeWin::PaintMenuBackground(SkCanvas* canvas,
                                          const gfx::Rect& rect) const {
   SkPaint paint;
   paint.setColor(GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor));
   canvas->drawRect(gfx::RectToSkRect(rect), paint);
 }
 
-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: {
+      sk_sp<SkSurface> surface(skia::MapPlatformSurface(hdc));
+      SkCanvas* canvas = surface ? surface->getCanvas() : nullptr;

[tomhudson, 2016/06/22 21:29:58]

This really *ought* to succeed, given that skia::SupportsPlatformPaint() was
true on the way in here; the null-checking is being conservative. In theory we
could just call surface->getCanvas()->drawColor(...) here.

[Peter Kasting, 2016/06/22 23:43:51]

If we're sure that has to work, I'd rather do that; extra null checks imply that
the calls in question can actually fail and can mislead later readers.

+      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 kSliderTrack:
     case kSliderThumb:
     case kMaxPart:
       NOTREACHED();
   }
 }
@@ skipping 192 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.
-  sk_sp<skia::BitmapPlatformDevice> device(
-      skia::BitmapPlatformDevice::Create(
-          rect.width(), rect.height(), false, NULL));
-  DCHECK(device);
-  SkCanvas offscreen_canvas(device.get());
-  DCHECK(skia::SupportsPlatformPaint(&offscreen_canvas));
+  base::win::ScopedCreateDC offscreen_hdc
+      (skia::CreateOffscreenSurface(rect.width(), rect.height()));
+  sk_sp<SkSurface> offscreen_surface
+      (skia::MapPlatformSurface(offscreen_hdc.Get()));
+  DCHECK(offscreen_surface);
+  SkCanvas* offscreen_canvas = offscreen_surface->getCanvas();
+  DCHECK(offscreen_canvas);

[Peter Kasting, 2016/06/22 02:23:34]

It's really unclear to me how we know when to null-check MapPlatformSurface()
and getCanvas() and handle failure, versus when we can DCHECK the result.  We do
both in this file.  Should we always be doing one or the other?  If not, do
these sites deserve comments about why they can fail in some places and not the
others?

[tomhudson, 2016/06/22 21:29:58]

We don't have any control over the canvas passed into Paint(), and it could be a
PlatformCanvas or a raw canvas (one without OS-specific backing). We want to do
different things depending on which it is.

However, the canvas created here through CreateOffscreenSurface() and subsequent
calls is being created to be a PlatformCanvas; if those return NULL, we have an
allocation failure or some other critical falut we aren't prepared to recover
from.

See caveat in line 444 above.

 
   // 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;
   }
+
+  SkBitmap bitmap = skia::ReadPixels(offscreen_canvas);
   // Draw the theme controls using existing HDC-drawing code.
-  PaintDirect(&offscreen_canvas, part, state, adjusted_rect, adjusted_extra);
-
-  SkBitmap bitmap = skia::ReadPixels(&offscreen_canvas);
+  PaintDirect(offscreen_hdc.Get(), 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.Get());
   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());
+  sk_sp<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());
 }
 
 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 {
+    sk_sp<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) {
+      sk_sp<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 650 matching lines @@
     break;
   case LAST:
     NOTREACHED();
     break;
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
 }  // namespace ui