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

skia/ext/bitmap_platform_device_win.cc

Index: skia/ext/bitmap_platform_device_win.cc
diff --git a/skia/ext/bitmap_platform_device_win.cc b/skia/ext/bitmap_platform_device_win.cc
index 09140a1ed6a8664cd2ecc5af30017643243a9f96..02ce038626d742c1b8d7278d5a54fb9a96de42e4 100644
--- a/skia/ext/bitmap_platform_device_win.cc
+++ b/skia/ext/bitmap_platform_device_win.cc
@@ -15,6 +15,68 @@
 
 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),
@@ -120,6 +182,11 @@ BitmapPlatformDevice* BitmapPlatformDevice::Create(
                                      &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;
   }