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,
+    base::win::ScopedCreateDC hdc(CreateCompatibleDC(NULL));
+    HBITMAP old_hbitmap =
+        static_cast<HBITMAP>(SelectObject(hdc.Get(), dst_hbitmap));
+    ::SetDIBitsToDevice(hdc.Get(), 0, 0, bitmap->bmiHeader.biWidth,
                         bitmap->bmiHeader.biHeight, 0, 0, 0,
                         bitmap->bmiHeader.biHeight, bitmap_bits, bitmap,
                         DIB_RGB_COLORS);
+    SelectObject(hdc.Get(), old_hbitmap);
   }
   // 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