Remove dead WebGraphicsContext3D initialization code

webkit/gpu/webgraphicscontext3d_in_process_impl.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 "webkit/gpu/webgraphicscontext3d_in_process_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <string>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_bindings_skia_in_process.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface.h"
 
 namespace webkit {
@@ skipping 40 matching lines @@
       bound_texture_(0),
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
       scanline_(0),
 #endif
       gl_context_(context),
       gl_surface_(surface),
       fragment_compiler_(0),
       vertex_compiler_(0) {
 }
 
+// All instances in a process that share resources are in the same share group.
+static base::LazyInstance<
+    std::set<WebGraphicsContext3DInProcessImpl*> >
+        g_all_shared_contexts = LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<base::Lock>::Leaky
+    g_all_shared_contexts_lock = LAZY_INSTANCE_INITIALIZER;
+
 WebGraphicsContext3DInProcessImpl::~WebGraphicsContext3DInProcessImpl() {
+  base::AutoLock a(g_all_shared_contexts_lock.Get());
+  g_all_shared_contexts.Pointer()->erase(this);
+
   if (!initialized_)
     return;
 
   makeContextCurrent();
 
   if (attributes_.antialias) {
     glDeleteRenderbuffersEXT(1, &multisample_color_buffer_);
     if (attributes_.depth || attributes_.stencil)
       glDeleteRenderbuffersEXT(1, &multisample_depth_stencil_buffer_);
     glDeleteFramebuffersEXT(1, &multisample_fbo_);
@@ skipping 16 matching lines @@
        ii != shader_source_map_.end(); ++ii) {
     if (ii->second)
       delete ii->second;
   }
   AngleDestroyCompilers();
 }
 
 WebGraphicsContext3DInProcessImpl*
 WebGraphicsContext3DInProcessImpl::CreateForWebView(
     WebGraphicsContext3D::Attributes attributes,
-    WebView* web_view,
     bool render_directly_to_web_view) {
   if (!gfx::GLSurface::InitializeOneOff())
     return NULL;
 
-  bool is_gles2 = gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
   gfx::GLShareGroup* share_group = 0;
-  if (!render_directly_to_web_view) {
-    // Pick up the compositor's context to share resources with.
-    WebGraphicsContext3D* view_context = web_view ?
-                                         web_view->graphicsContext3D() : NULL;
-    if (view_context) {
-      WebGraphicsContext3DInProcessImpl* contextImpl =
-          static_cast<WebGraphicsContext3DInProcessImpl*>(view_context);
-      share_group = contextImpl->gl_context_->share_group();
-    } else {
-      // The compositor's context didn't get created
-      // successfully, so conceptually there is no way we can
-      // render successfully to the WebView.
-      render_directly_to_web_view = false;
-    }
+
+  if (attributes.shareResources) {
+    WebGraphicsContext3DInProcessImpl* context_impl =
+      g_all_shared_contexts.Pointer()->empty() ?
+        NULL : *g_all_shared_contexts.Pointer()->begin();
+    share_group = context_impl->gl_context_->share_group();
   }
 
   // This implementation always renders offscreen regardless of whether
   // render_directly_to_web_view is true. Both DumpRenderTree and test_shell
   // paint first to an intermediate offscreen buffer and from there to the
   // window, and WebViewImpl::paint already correctly handles the case where the
   // compositor is active but the output needs to go to a WebCanvas.
   scoped_refptr<gfx::GLSurface> gl_surface =
       gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
 
-  if (!gl_surface.get()) {
-    if (!is_gles2)
-      return NULL;
-
-    // Embedded systems have smaller limit on number of GL contexts. Sometimes
-    // failure of GL context creation is because of existing GL contexts
-    // referenced by JavaScript garbages. Collect garbage and try again.
-    // TODO: Besides this solution, kbr@chromium.org suggested: upon receiving
-    // a page unload event, iterate down any live WebGraphicsContext3D instances
-    // and force them to drop their contexts, sending a context lost event if
-    // necessary.
-    if (web_view) web_view->mainFrame()->collectGarbage();
-
-    gl_surface = gfx::GLSurface::CreateOffscreenGLSurface(false,
-                                                          gfx::Size(1, 1));
-    if (!gl_surface.get())
-      return NULL;
-  }
+  if (!gl_surface.get())
+    return NULL;
 
   // TODO(kbr): This implementation doesn't yet support lost contexts
   // and therefore can't yet properly support GPU switching.
   gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
   scoped_refptr<gfx::GLContext> gl_context = gfx::GLContext::CreateGLContext(
       share_group,
       gl_surface.get(),
       gpu_preference);
 
-  if (!gl_context.get()) {
-    if (!is_gles2)
-      return NULL;
+  if (!gl_context.get())
+    return NULL;
 
-    // Embedded systems have smaller limit on number of GL contexts. Sometimes
-    // failure of GL context creation is because of existing GL contexts
-    // referenced by JavaScript garbages. Collect garbage and try again.
-    // TODO: Besides this solution, kbr@chromium.org suggested: upon receiving
-    // a page unload event, iterate down any live WebGraphicsContext3D instances
-    // and force them to drop their contexts, sending a context lost event if
-    // necessary.
-    if (web_view)
-      web_view->mainFrame()->collectGarbage();
-
-    gl_context = gfx::GLContext::CreateGLContext(share_group,
-                                                 gl_surface.get(),
-                                                 gpu_preference);
-    if (!gl_context.get())
-      return NULL;
-  }
   scoped_ptr<WebGraphicsContext3DInProcessImpl> context(
       new WebGraphicsContext3DInProcessImpl(
         gl_surface.get(), gl_context.get(), render_directly_to_web_view));
   if (!context->Initialize(attributes))
     return NULL;
   return context.release();
 }
 
 WebGraphicsContext3DInProcessImpl*
 WebGraphicsContext3DInProcessImpl::CreateForWindow(
@@ skipping 64 matching lines @@
     glEnable(GL_POINT_SPRITE);
   }
 
   if (!AngleCreateCompilers()) {
     AngleDestroyCompilers();
     return false;
   }
 
   initialized_ = true;
   gl_context_->ReleaseCurrent(gl_surface_.get());
+
+  if (attributes_.shareResources)
+    g_all_shared_contexts.Pointer()->insert(this);
+
   return true;
 }
 
 void WebGraphicsContext3DInProcessImpl::ValidateAttributes() {
   const char* extensions =
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
 
   if (attributes_.stencil) {
     if (strstr(extensions, "GL_OES_packed_depth_stencil") ||
         strstr(extensions, "GL_EXT_packed_depth_stencil")) {
@@ skipping 1455 matching lines @@
   if (length > 1) {
     entry->translated_source.reset(new char[length]);
     ShGetObjectCode(compiler, entry->translated_source.get());
   }
   entry->is_valid = true;
   return true;
 }
 
 }  // namespace gpu
 }  // namespace webkit