Fix win32 error checking in platform_canvas_skia.cc by moving code into ...

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 "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkUtils.h"
 
 namespace skia {
 
+// Disable optimizations during crash analysis.
+#pragma optimize("", off)
+
+// Crash On Failure. |address| should be a number less than 4000.
+#define COF(address, condition) if (!(condition)) *((int*) address) = 0
+
+// This is called when a bitmap allocation fails, and this function tries to
+// determine why it might have failed, and crash on different
+// lines. This allows us to see in crash dumps the most likely reason for the
+// failure. It takes the size of the bitmap we were trying to allocate as its
+// arguments so we can check that as well.
+//
+// Note that in a sandboxed renderer this function crashes when trying to
+// call GetProcessMemoryInfo() because it tries to load psapi.dll, which
+// is fine but gives you a very hard to read crash dump.
+void CrashForBitmapAllocationFailure(int w, int h, unsigned int error) {
+  // Store the extended error info in a place easy to find at debug time.
+  unsigned int diag_error = 0;
+  // If the bitmap is ginormous, then we probably can't allocate it.
+  // We use 32M pixels = 128MB @ 4 bytes per pixel.
+  const LONG_PTR kGinormousBitmapPxl = 32000000;
+  COF(1, LONG_PTR(w) * LONG_PTR(h) < kGinormousBitmapPxl);
+
+  // The maximum number of GDI objects per process is 10K. If we're very close
+  // to that, it's probably the problem.
+  const unsigned int kLotsOfGDIObjects = 9990;
+  unsigned int num_gdi_objects = GetGuiResources(GetCurrentProcess(),
+                                                 GR_GDIOBJECTS);
+  if (num_gdi_objects == 0) {
+    diag_error = GetLastError();
+    COF(2, false);
+  }
+  COF(3, num_gdi_objects < kLotsOfGDIObjects);
+
+  // If we're using a crazy amount of virtual address space, then maybe there
+  // isn't enough for our bitmap.
+  const SIZE_T kLotsOfMem = 1500000000;  // 1.5GB.
+  PROCESS_MEMORY_COUNTERS_EX pmc;
+  pmc.cb = sizeof(pmc);
+  if (!GetProcessMemoryInfo(GetCurrentProcess(),
+                            reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&pmc),
+                            sizeof(pmc))) {
+    diag_error = GetLastError();
+    COF(4, false);
+  }
+  COF(5, pmc.PagefileUsage < kLotsOfMem);
+  COF(6, pmc.PrivateUsage < kLotsOfMem);
+  // Ok but we are somehow out of memory?
+  COF(7, error != ERROR_NOT_ENOUGH_MEMORY);
+}
+
+// Crashes the process. This is called when a bitmap allocation fails but
+// unlike its cousin CrashForBitmapAllocationFailure() it tries to detect if
+// the issue was a non-valid shared bitmap handle.
+void CrashIfInvalidSection(HANDLE shared_section) {
+  DWORD handle_info = 0;
+  COF(8, ::GetHandleInformation(shared_section, &handle_info) == TRUE);
+}
+
+// Restore the optimization options.
+#pragma optimize("", on)
+
 BitmapPlatformDevice::BitmapPlatformDeviceData::BitmapPlatformDeviceData(
     HBITMAP hbitmap)
     : bitmap_context_(hbitmap),
       hdc_(NULL),
       config_dirty_(true),  // Want to load the config next time.
       transform_(SkMatrix::I()) {
   // Initialize the clip region to the entire bitmap.
   BITMAP bitmap_data;
   if (GetObject(bitmap_context_, sizeof(BITMAP), &bitmap_data)) {
     SkIRect rect;
@@ skipping 85 matching lines @@
   hdr.biYPelsPerMeter = 1;
   hdr.biClrUsed = 0;
   hdr.biClrImportant = 0;
 
   void* data = NULL;
   HBITMAP hbitmap = CreateDIBSection(NULL,
                                      reinterpret_cast<BITMAPINFO*>(&hdr), 0,
                                      &data,
                                      shared_section, 0);
   if (!hbitmap) {
+    // Investigate we failed. If we know the reason, crash in a specific place.
+    unsigned int error = GetLastError();
+    if (shared_section)
+      CrashIfInvalidSection(shared_section);
+    CrashForBitmapAllocationFailure(width, height, error);

[Alexei Svitkine (slow), 2012/04/16 19:01:44]

Can you explain why it makes sense to move this here? Is this the only way
initializeWithDevice() can fail?

Can you also CC whoever added this code since I'm assuming it's related to an
issue currently being debugged.

     return NULL;
   }
 
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
   bitmap.setPixels(data);
   bitmap.setIsOpaque(is_opaque);
 
 #ifndef NDEBUG
   // If we were given data, then don't clobber it!
   if (!shared_section && is_opaque)
@@ skipping 124 matching lines @@
 SkDevice* BitmapPlatformDevice::onCreateCompatibleDevice(
     SkBitmap::Config config, int width, int height, bool isOpaque,
     Usage /*usage*/) {
   SkASSERT(config == SkBitmap::kARGB_8888_Config);
   SkDevice* bitmap_device = BitmapPlatformDevice::CreateAndClear(width, height,
                                                                  isOpaque);
   return bitmap_device;
 }
 
 }  // namespace skia