don't need gfx::Canvas and its native context to convert HBITMAP

ui/base/clipboard/clipboard_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.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
 #include "ui/base/clipboard/clipboard_win.h"
 
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/message_window.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
+#include "skia/ext/skia_utils_win.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/clipboard_util_win.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 566 matching lines @@
         color_table_length = 3;
       break;
     case 24:
       break;
     default:
       NOTREACHED();
   }
   const void* bitmap_bits = reinterpret_cast<const char*>(bitmap)
       + bitmap->bmiHeader.biSize + color_table_length * sizeof(RGBQUAD);
 
-  gfx::Canvas canvas(gfx::Size(bitmap->bmiHeader.biWidth,
-                               bitmap->bmiHeader.biHeight),
-                     1.0f,
-                     false);
+  void* dst_bits;
+  // dst_hbitmap is freed by the release_proc in skia_bitmap (below)
+  HBITMAP dst_hbitmap =
+      skia::CreateHBitmap(bitmap->bmiHeader.biWidth, bitmap->bmiHeader.biHeight,
+                          false, 0, &dst_bits);
+
   {
-    HDC dc = skia::GetNativeDrawingContext(canvas.sk_canvas());
-    ::SetDIBitsToDevice(dc, 0, 0, bitmap->bmiHeader.biWidth,
-                        bitmap->bmiHeader.biHeight, 0, 0, 0,
-                        bitmap->bmiHeader.biHeight, bitmap_bits, bitmap,
-                        DIB_RGB_COLORS);
+    HDC hdc = CreateCompatibleDC(NULL);

[dcheng, 2017/01/04 22:25:36]

Nit: nullptr, and use ScopedCreateDC from base/win

[reed1, 2017/01/05 02:24:46]

I would use it like this? ScopedCreateDC scoped(::CreateCompatibleDC(NULL));

That classes doesn't seems to do anything with selecting in and out of my
hbitmap. Is it applicable in my case?

[dcheng, 2017/01/05 02:39:50]

Yes, it would still need to be selected, but it would automatically handle the
DeleteDC call.

[reed1, 2017/01/05 16:49:09]

Done.

+    skia::InitializeDC(hdc);

[dcheng, 2017/01/04 22:25:36]

Just curious: do we need to do this if we're just going to call
SetDIBitsToDevice?

[reed1, 2017/01/05 02:24:46]

I need to draw 'bitmap' into my dst_hbitmap. Don't I need to create a DC around
dst_hbitmap to do that?

[dcheng, 2017/01/05 02:39:50]

I think the DC should already be initialized; it looks like InitializeDC just
sets up some defaults that we shouldn't have to use anyway.

[reed1, 2017/01/05 03:16:08]

Ah, I misinterpreted your question. Got it about InitializeDC. Thanks.

+    HBITMAP old_hbitmap = static_cast<HBITMAP>(SelectObject(hdc, dst_hbitmap));
+    ::SetDIBitsToDevice(
+        hdc, 0, 0, bitmap->bmiHeader.biWidth, bitmap->bmiHeader.biHeight, 0, 0,
+        0, bitmap->bmiHeader.biHeight, bitmap_bits, bitmap, DIB_RGB_COLORS);
+    SelectObject(hdc, old_hbitmap);
+    DeleteDC(hdc);
   }
   // Windows doesn't really handle alpha channels well in many situations. When
   // the source image is < 32 bpp, we force the bitmap to be opaque. When the
   // source image is 32 bpp, the alpha channel might still contain garbage data.
   // Since Windows uses premultiplied alpha, we scan for instances where
   // (R, G, B) > A. If there are any invalid premultiplied colors in the image,
   // we assume the alpha channel contains garbage and force the bitmap to be
   // opaque as well. Note that this  heuristic will fail on a transparent bitmap
   // containing only black pixels...
-  SkPixmap device_pixels;
-  skia::GetWritablePixels(canvas.sk_canvas(), &device_pixels);
+  SkPixmap device_pixels(SkImageInfo::MakeN32Premul(bitmap->bmiHeader.biWidth,
+                                                    bitmap->bmiHeader.biHeight),
+                         dst_bits, bitmap->bmiHeader.biWidth * 4);
+
   {
     bool has_invalid_alpha_channel = bitmap->bmiHeader.biBitCount < 32 ||
         BitmapHasInvalidPremultipliedColors(device_pixels);
     if (has_invalid_alpha_channel) {
       MakeBitmapOpaque(&device_pixels);
     }
   }
 
-  return canvas.ExtractImageRep().sk_bitmap();
+  SkBitmap skia_bitmap;
+  skia_bitmap.installPixels(device_pixels.info(), device_pixels.writable_addr(),
+                            device_pixels.rowBytes(), nullptr,
+                            [](void* pixels, void* hbitmap) {
+                              DeleteObject(static_cast<HBITMAP>(hbitmap));
+                            },
+                            dst_hbitmap);
+  return skia_bitmap;
 }
 
 void ClipboardWin::ReadCustomData(ClipboardType clipboard_type,
                                   const base::string16& type,
                                   base::string16* result) const {
   DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE);
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
@@ skipping 227 matching lines @@
   if (!clipboard_owner_)
     return NULL;
 
   if (clipboard_owner_->hwnd() == NULL)
     clipboard_owner_->Create(base::Bind(&ClipboardOwnerWndProc));
 
   return clipboard_owner_->hwnd();
 }
 
 }  // namespace ui