Aggressively assert on BITMAP object deletions

skia/ext/bitmap_platform_device_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 <windows.h>
 #include <psapi.h>
 
 #include "skia/ext/bitmap_platform_device_win.h"
 #include "skia/ext/bitmap_platform_device_data.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 39 matching lines @@
   hdr.biBitCount = 32;
   hdr.biCompression = BI_RGB;  // no compression
   hdr.biSizeImage = 0;
   hdr.biXPelsPerMeter = 1;
   hdr.biYPelsPerMeter = 1;
   hdr.biClrUsed = 0;
   hdr.biClrImportant = 0;
 
   HBITMAP hbitmap = CreateDIBSection(NULL, reinterpret_cast<BITMAPINFO*>(&hdr),
                                      0, data, shared_section, 0);
+
+  if (!hbitmap) {
+    // Attempt to create a smaller DIBSection to debug whether
+    // the failure was due to memory exhaustion/fragmentation
+    // or GDI resource exhaution.
+    // See crbug.com/275046
+    hdr.biWidth = 5;
+    hdr.biHeight = 5;
+    void* small_data;
+    HBITMAP small_bitmap = CreateDIBSection(
+        NULL, reinterpret_cast<BITMAPINFO*>(&hdr),
+        0, &small_data, shared_section, 0);
+    if (!small_bitmap)
+      SK_CRASH();
+    BITMAP bitmap_data;
+    if (GetObject(small_bitmap, sizeof(BITMAP), &bitmap_data))
+      if (!DeleteObject(small_bitmap))
+        SK_CRASH();
+  }
+
   return hbitmap;
 }
 
 PlatformBitmapPixelRef::PlatformBitmapPixelRef(HBITMAP bitmap_handle,
                                                void* pixels)
     : bitmap_handle_(bitmap_handle),
       pixels_(pixels) {
   setPreLocked(pixels, NULL);
 }
 
 PlatformBitmapPixelRef::~PlatformBitmapPixelRef() {
   if (bitmap_handle_)
-    DeleteObject(bitmap_handle_);
+    if (!DeleteObject(bitmap_handle_))
+      SK_CRASH();
 }
 
 void* PlatformBitmapPixelRef::onLockPixels(SkColorTable** color_table) {
   *color_table = NULL;
   return pixels_;
 }
 
 void PlatformBitmapPixelRef::onUnlockPixels() {
   // Nothing to do.
   return;
@@ skipping 16 matching lines @@
     rect.set(0, 0, bitmap_data.bmWidth, bitmap_data.bmHeight);
     clip_region_ = SkRegion(rect);
   }
 }
 
 BitmapPlatformDevice::BitmapPlatformDeviceData::~BitmapPlatformDeviceData() {
   if (hdc_)
     ReleaseBitmapDC();
 
   // this will free the bitmap data as well as the bitmap handle
-  DeleteObject(bitmap_context_);
+  if (!DeleteObject(bitmap_context_))
+    SK_CRASH();
 }
 
 HDC BitmapPlatformDevice::BitmapPlatformDeviceData::GetBitmapDC() {
   if (!hdc_) {
     hdc_ = CreateCompatibleDC(NULL);
     InitializeDC(hdc_);
     HGDIOBJ old_bitmap = SelectObject(hdc_, bitmap_context_);
     // When the memory DC is created, its display surface is exactly one
     // monochrome pixel wide and one monochrome pixel high. Since we select our
     // own bitmap, we must delete the previous one.
-    DeleteObject(old_bitmap);
+    if (!DeleteObject(old_bitmap))
+      SK_CRASH();
   }
 
   LoadConfig();
   return hdc_;
 }
 
 void BitmapPlatformDevice::BitmapPlatformDeviceData::ReleaseBitmapDC() {
   SkASSERT(hdc_);
-  DeleteDC(hdc_);
+  if (!DeleteDC(hdc_))
+    SK_CRASH();
   hdc_ = NULL;
 }
 
 bool BitmapPlatformDevice::BitmapPlatformDeviceData::IsBitmapDCCreated()
     const {
   return hdc_ != NULL;
 }
 
 
 void BitmapPlatformDevice::BitmapPlatformDeviceData::SetMatrixClip(
@@ skipping 178 matching lines @@
       BitmapPlatformDevice::Create(width, height, is_opaque, shared_section));
   return CreateCanvas(dev, failureType);
 }
 
 // Port of PlatformBitmap to win
 
 PlatformBitmap::~PlatformBitmap() {
   if (surface_) {
     if (platform_extra_)
       SelectObject(surface_, reinterpret_cast<HGDIOBJ>(platform_extra_));
-    DeleteDC(surface_);
+    if (!DeleteDC(surface_))
+      SK_CRASH();
   }
 }
 
 bool PlatformBitmap::Allocate(int width, int height, bool is_opaque) {
   void* data;
   HBITMAP hbitmap = CreateHBitmap(width, height, is_opaque, 0, &data);
   if (!hbitmap)
     return false;
 
   surface_ = CreateCompatibleDC(NULL);
   InitializeDC(surface_);
   // When the memory DC is created, its display surface is exactly one
   // monochrome pixel wide and one monochrome pixel high. Save this object
   // off, we'll restore it just before deleting the memory DC.
   HGDIOBJ stock_bitmap = SelectObject(surface_, hbitmap);
   platform_extra_ = reinterpret_cast<intptr_t>(stock_bitmap);
 
   bitmap_.setConfig(SkBitmap::kARGB_8888_Config, width, height, 0,
                     is_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
   // PlatformBitmapPixelRef takes ownership of |hbitmap|.
   bitmap_.setPixelRef(
       skia::AdoptRef(new PlatformBitmapPixelRef(hbitmap, data)).get());
   bitmap_.lockPixels();
 
   return true;
 }
 
 }  // namespace skia