Improve usefulness of webglcontextcreationerror statusMessage

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 508 matching lines @@
         visitor->trace(m_context);
     }
 
 private:
     explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* context)
         : m_context(context) { }
 
     RawPtrWillBeMember<WebGLRenderingContextBase> m_context;
 };
 
+static void formatWebGLStatusString(const String& glInfo, const String& infostring, String& statusMessage)
+{
+    if (!infostring.isEmpty())
+        statusMessage.append(", " + glInfo + " = " + infostring);
+}
+
+static String extractWebGLContextCreationError(const WebGraphicsContext3D::WebGraphicsInfo& info)
+{
+    String statusMessage("Could not create a WebGL context");
+    if (info.vendorId)
+        formatWebGLStatusString("VENDOR", String::format("0x%04x", info.vendorId).utf8().data(), statusMessage);
+    if (info.deviceId)
+        formatWebGLStatusString("DEVICE", String::format("0x%04x", info.deviceId).utf8().data(), statusMessage);
+    formatWebGLStatusString("GL_VENDOR", info.vendorInfo.utf8().data(), statusMessage);
+    formatWebGLStatusString("GL_RENDERER", info.rendererInfo.utf8().data(), statusMessage);
+    formatWebGLStatusString("GL_VERSION", info.driverVersion.utf8().data(), statusMessage);
+    formatWebGLStatusString("Sandboxed", info.sandboxed ? "yes" : "no", statusMessage);
+    formatWebGLStatusString("Optimus", info.optimus ? "yes" : "no", statusMessage);
+    formatWebGLStatusString("AMD switchable", info.amdSwitchable ? "yes" : "no", statusMessage);
+    formatWebGLStatusString("Reset notification strategy", String::format("0x%04x", info.resetNotificationStrategy).utf8().data(), statusMessage);
+    formatWebGLStatusString("GPU process crash count", String::number(info.processCrashCount).utf8().data(), statusMessage);
+    formatWebGLStatusString("ErrorMessage", info.errorMessage.utf8().data(), statusMessage);
+    statusMessage.append(".");
+    return statusMessage;
+}
+
 PassOwnPtr<WebGraphicsContext3D> WebGLRenderingContextBase::createWebGraphicsContext3D(HTMLCanvasElement* canvas, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
     Document& document = canvas->document();
     LocalFrame* frame = document.frame();
     if (!frame) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
     Settings* settings = frame->settings();
 
     // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
     // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled())) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
 
     WebGraphicsContext3D::Attributes wgc3dAttributes = toWebGraphicsContext3DAttributes(attributes, document.topDocument().url().string(), settings, webGLVersion);
-    WebGLInfo glInfo;
-    OwnPtr<WebGraphicsContext3D> context = adoptPtr(Platform::current()->createOffscreenGraphicsContext3D(wgc3dAttributes, 0, &glInfo));
+    WebGraphicsContext3D::WebGraphicsInfo glInfo;
+    glInfo.testFailContext = shouldFailContextCreationForTesting;
+    OwnPtr<WebGraphicsContext3D> context = adoptPtr(Platform::current()->createOffscreenGraphicsContext3D(wgc3dAttributes, 0, glInfo));
     if (!context || shouldFailContextCreationForTesting) {
         shouldFailContextCreationForTesting = false;
-        String statusMessage;
-        if (!glInfo.contextInfoCollectionFailure.isEmpty()) {
-            statusMessage.append("Could not create a WebGL context. ");
-            statusMessage.append(glInfo.contextInfoCollectionFailure);
-            String vendorId = String::number(glInfo.vendorId);
-            String deviceId = String::number(glInfo.deviceId);
-            if (vendorId.isEmpty())
-                statusMessage.append("VendorId = Not Available");
-            else
-                statusMessage.append("VendorId = " + vendorId);
-            if (deviceId.isEmpty())
-                statusMessage.append(", DeviceId = Not Available");
-            else
-                statusMessage.append(", DeviceId = " + deviceId);
-        } else {
-            statusMessage.append("Could not create a WebGL context");
-            if (!glInfo.vendorInfo.isEmpty()) {
-                statusMessage.append(", VendorInfo = ");
-                statusMessage.append(glInfo.vendorInfo);
-            } else {
-                statusMessage.append(", VendorInfo = Not Available");
-            }
-            if (!glInfo.rendererInfo.isEmpty()) {
-                statusMessage.append(", RendererInfo = ");
-                statusMessage.append(glInfo.rendererInfo);
-            } else {
-                statusMessage.append(", RendererInfo = Not Available");
-            }
-            if (!glInfo.driverVersion.isEmpty()) {
-                statusMessage.append(", DriverInfo = ");
-                statusMessage.append(glInfo.driverVersion);
-            } else {
-                statusMessage.append(", DriverInfo = Not Available");
-            }
-            statusMessage.append(".");
-        }
-        canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, statusMessage));
+        canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, extractWebGLContextCreationError(glInfo)));
         return nullptr;
     }
 
     return context.release();
 }
 
 void WebGLRenderingContextBase::forceNextWebGLContextCreationToFail()
 {
     shouldFailContextCreationForTesting = true;
 }
@@ skipping 299 matching lines @@
     RefPtr<DrawingBuffer> buffer = createDrawingBuffer(context);
     if (!buffer) {
         m_contextLostMode = SyntheticLostContext;
         return;
     }
 
     m_drawingBuffer = buffer.release();
 
     drawingBuffer()->bind(GL_FRAMEBUFFER);
     setupFlags();
-    
+
 #define ADD_VALUES_TO_SET(set, values) \
     for (size_t i = 0; i < arraysize(values); ++i) {   \
         set.insert(values[i]);                         \
     }
 
     ADD_VALUES_TO_SET(m_supportedInternalFormats, kSupportedInternalFormatsES2);
     ADD_VALUES_TO_SET(m_supportedFormats, kSupportedFormatsES2);
     ADD_VALUES_TO_SET(m_supportedTypes, kSupportedTypesES2);
     ADD_VALUES_TO_SET(m_supportedFormatTypeCombinations, kSupportedFormatTypesES2);
 }
@@ skipping 5813 matching lines @@
 
     return totalBytesPerPixel;
 }
 
 DrawingBuffer* WebGLRenderingContextBase::drawingBuffer() const
 {
     return m_drawingBuffer.get();
 }
 
 } // namespace blink