Merge 73424 - 2010-12-06 Alexey Marinichev <amarinichev@chromium.org>...

WebCore/html/canvas/WebGLRenderingContext.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 44 matching lines @@
 #include "WebGLRenderbuffer.h"
 #include "WebGLShader.h"
 #include "WebGLTexture.h"
 #include "WebGLUniformLocation.h"
 
 #include <wtf/ByteArray.h>
 #include <wtf/OwnArrayPtr.h>
 
 namespace WebCore {
 
+const double secondsBetweenRestoreAttempts = 1.0;
+
 static inline Platform3DObject objectOrZero(WebGLObject* object)
 {
     return object ? object->object() : 0;
 }
 
 class WebGLStateRestorer {
 public:
     WebGLStateRestorer(WebGLRenderingContext* context,
                        bool changed)
         : m_context(context)
         , m_changed(changed)
     {
     }
 
     ~WebGLStateRestorer()
     {
         m_context->cleanupAfterGraphicsCall(m_changed);
     }
 
 private:
     WebGLRenderingContext* m_context;
     bool m_changed;
 };
 
+void WebGLRenderingContext::WebGLRenderingContextRestoreTimer::fired()
+{
+    // Timer is started when m_contextLost is false.  It will first call
+    // loseContext, which will set m_contextLost to true.  Then it will keep
+    // calling restoreContext and reschedule itself until m_contextLost is back
+    // to false.
+    if (!m_context->m_contextLost) {
+        m_context->loseContext();
+        startOneShot(secondsBetweenRestoreAttempts);
+    } else {
+        // The rendering context is not restored if there is no handler for
+        // the context restored event.
+        if (!m_context->canvas()->hasEventListeners(eventNames().webglcontextrestoredEvent))
+            return;
+
+        m_context->restoreContext();
+        if (m_context->m_contextLost)
+            startOneShot(secondsBetweenRestoreAttempts);
+    }
+}
+
 PassOwnPtr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)
 {
     HostWindow* hostWindow = canvas->document()->view()->root()->hostWindow();
-    GraphicsContext3D::Attributes emptyAttributes;
-    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attrs ? attrs->attributes() : emptyAttributes, hostWindow));
+    GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();
+    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes, hostWindow));
 
     if (!context) {
         canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));
         return 0;
     }
         
-    return new WebGLRenderingContext(canvas, context);
+    return new WebGLRenderingContext(canvas, context, attributes);
 }
 
-WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context)
+WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,
+                                             GraphicsContext3D::Attributes attributes)
     : CanvasRenderingContext(passedCanvas)
     , m_context(context)
+    , m_restoreTimer(this)
     , m_videoCache(4)
     , m_contextLost(false)
+    , m_attributes(attributes)
 {
     ASSERT(m_context);
     setupFlags();
     initializeNewContext();
 }
 
 void WebGLRenderingContext::initializeNewContext()
 {
     m_needsUpdate = true;
     m_markedCanvasDirty = false;
@@ skipping 1965 matching lines @@
 {
     if (!buffer || isContextLost())
         return false;
 
     if (!buffer->hasEverBeenBound())
         return false;
 
     return m_context->isBuffer(buffer->object());
 }
 
-bool WebGLRenderingContext::isContextLost() const
+bool WebGLRenderingContext::isContextLost()
 {
+    if (m_restoreTimer.isActive())
+        return true;
+
+    bool newContextLost = m_context->getExtensions()->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR;
+
+    if (newContextLost != m_contextLost)
+        m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts);
+
     return m_contextLost;
 }
 
 bool WebGLRenderingContext::isEnabled(unsigned long cap)
 {
     if (!validateCapability(cap) || isContextLost())
         return false;
     return m_context->isEnabled(cap);
 }
 
@@ skipping 1133 matching lines @@
     if (isnan(width))
         width = 100;
     if (isnan(height))
         height = 100;
     m_context->viewport(x, y, width, height);
     cleanupAfterGraphicsCall(false);
 }
 
 void WebGLRenderingContext::loseContext()
 {
-    if (isContextLost())
-        return;
-
     m_contextLost = true;
 
     detachAndRemoveAllObjects();
 
     // There is no direct way to clear errors from a GL implementation and
     // looping until getError() becomes NO_ERROR might cause an infinite loop if
     // the driver or context implementation had a bug.  So, loop a reasonably
     // large number of times to clear any existing errors.
     for (int i = 0; i < 100; ++i) {
         if (m_context->getError() == GraphicsContext3D::NO_ERROR)
             break;
     }
     m_context->synthesizeGLError(GraphicsContext3D::CONTEXT_LOST_WEBGL);
 
     canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, ""));
 }
 
 void WebGLRenderingContext::restoreContext()
 {
-    if (!isContextLost())
+    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes, canvas()->document()->view()->root()->hostWindow()));
+    if (!context)
         return;
 
-    // The rendering context is not restored if there is no handler for
-    // the context restored event.
-    if (!canvas()->hasEventListeners(eventNames().webglcontextrestoredEvent))
-        return;
-
+    m_context = context;
+    initializeNewContext();
     m_contextLost = false;
-    initializeNewContext();
-
     canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, ""));
 }
 
 void WebGLRenderingContext::removeObject(WebGLObject* object)
 {
     m_canvasObjects.remove(object);
 }
 
 void WebGLRenderingContext::addObject(WebGLObject* object)
 {
@@ skipping 793 matching lines @@
 
 void WebGLRenderingContext::LRUImageBufferCache::bubbleToFront(int idx)
 {
     for (int i = idx; i > 0; --i)
         m_buffers[i].swap(m_buffers[i-1]);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(3D_CANVAS)