Refactor WebGraphicsContext3DInProcess and TestWebGraphicsContext3D

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>
@@ skipping 26 matching lines @@
   }
 
   WGC3Denum type;
   scoped_array<char> source;
   scoped_array<char> log;
   scoped_array<char> translated_source;
   bool is_valid;
 };
 
 WebGraphicsContext3DInProcessImpl::WebGraphicsContext3DInProcessImpl(
-    gfx::AcceleratedWidget window,
-    gfx::GLShareGroup* share_group)
+    gfx::GLSurface* surface,
+    gfx::GLContext* context,
+    bool render_directly_to_web_view)
     : initialized_(false),
-      render_directly_to_web_view_(false),
+      render_directly_to_web_view_(render_directly_to_web_view),
       is_gles2_(false),
       have_ext_framebuffer_object_(false),
       have_ext_framebuffer_multisample_(false),
       have_angle_framebuffer_multisample_(false),
       texture_(0),
       fbo_(0),
       depth_stencil_buffer_(0),
       cached_width_(0),
       cached_height_(0),
       multisample_fbo_(0),
       multisample_depth_stencil_buffer_(0),
       multisample_color_buffer_(0),
       bound_fbo_(0),
       bound_texture_(0),
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
       scanline_(0),
 #endif
+      gl_context_(context),
+      gl_surface_(surface),
       fragment_compiler_(0),
-      vertex_compiler_(0),
-      window_(window),
-      share_group_(share_group) {
+      vertex_compiler_(0) {
 }
 
 WebGraphicsContext3DInProcessImpl::~WebGraphicsContext3DInProcessImpl() {
   if (!initialized_)
     return;
 
   makeContextCurrent();
 
   if (attributes_.antialias) {
     glDeleteRenderbuffersEXT(1, &multisample_color_buffer_);
@@ skipping 16 matching lines @@
   gl_surface_->Destroy();
 
   for (ShaderSourceMap::iterator ii = shader_source_map_.begin();
        ii != shader_source_map_.end(); ++ii) {
     if (ii->second)
       delete ii->second;
   }
   AngleDestroyCompilers();
 }
 
-bool WebGraphicsContext3DInProcessImpl::initialize(
+WebGraphicsContext3DInProcessImpl*
+WebGraphicsContext3DInProcessImpl::CreateForWebView(
     WebGraphicsContext3D::Attributes attributes,
-    WebView* webView,
+    WebView* web_view,
     bool render_directly_to_web_view) {
   if (!gfx::GLSurface::InitializeOneOff())
-    return false;
+    return NULL;
 
-  render_directly_to_web_view_ = render_directly_to_web_view;
+  bool is_gles2 = gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
   gfx::GLShareGroup* share_group = 0;
-
-  is_gles2_ = gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
-
-  if (window_ != gfx::kNullPluginWindow) {
-    share_group = share_group_;
-    gl_surface_ = gfx::GLSurface::CreateViewGLSurface(false, window_);
-  } else {
-    if (!render_directly_to_web_view) {
-      // Pick up the compositor's context to share resources with.
-      WebGraphicsContext3D* view_context = webView ?
-                                           webView->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 (!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;
     }
-    // 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.
-    gl_surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false,
-        gfx::Size(1, 1));
   }
 
-  if (!gl_surface_.get()) {
-    if (!is_gles2_)
-      return false;
+  // 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 (webView) webView->mainFrame()->collectGarbage();
+    if (web_view) web_view->mainFrame()->collectGarbage();
 
-    gl_surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false,
-                                                           gfx::Size(1, 1));
-    if (!gl_surface_.get())
-      return false;
+    gl_surface = gfx::GLSurface::CreateOffscreenGLSurface(false,
+                                                          gfx::Size(1, 1));
+    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;
 
-  gl_context_ = gfx::GLContext::CreateGLContext(share_group,
-                                                gl_surface_.get(),
-                                                gpu_preference);
-  if (!gl_context_.get()) {
-    if (!is_gles2_)
-      return false;
+  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;
 
     // 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 (webView) webView->mainFrame()->collectGarbage();
+    if (web_view)
+      web_view->mainFrame()->collectGarbage();
 
-    gl_context_ = gfx::GLContext::CreateGLContext(share_group,
-                                                  gl_surface_.get(),
-                                                  gpu_preference);
-    if (!gl_context_.get())
-      return false;
+    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(
+    WebGraphicsContext3D::Attributes attributes,
+    gfx::AcceleratedWidget window,
+    gfx::GLShareGroup* share_group) {
+  if (!gfx::GLSurface::InitializeOneOff())
+    return NULL;
+
+  scoped_refptr<gfx::GLSurface> gl_surface =
+      gfx::GLSurface::CreateViewGLSurface(false, window);
+  if (!gl_surface.get())
+    return NULL;
+
+  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())
+    return NULL;
+  scoped_ptr<WebGraphicsContext3DInProcessImpl> context(
+      new WebGraphicsContext3DInProcessImpl(
+          gl_surface.get(), gl_context.get(), true));
+  if (!context->Initialize(attributes))
+    return NULL;
+  return context.release();
+}
+
+bool WebGraphicsContext3DInProcessImpl::Initialize(
+    WebGraphicsContext3D::Attributes attributes) {
+  is_gles2_ = gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
+
 
   attributes_ = attributes;
 
   // FIXME: for the moment we disable multisampling for the compositor.
   // It actually works in this implementation, but there are a few
   // considerations. First, we likely want to reduce the fuzziness in
   // these tests as much as possible because we want to run pixel tests.
   // Second, Mesa's multisampling doesn't seem to antialias straight
   // edges in some CSS 3D samples. Third, we don't have multisampling
   // support for the compositor in the normal case at the time of this
   // writing.
-  if (render_directly_to_web_view)
+  if (render_directly_to_web_view_)
     attributes_.antialias = false;
 
   if (!gl_context_->MakeCurrent(gl_surface_.get())) {
     gl_context_ = NULL;
     return false;
   }
 
   const char* extensions =
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
   DCHECK(extensions);
@@ skipping 101 matching lines @@
 bool WebGraphicsContext3DInProcessImpl::setParentContext(
     WebGraphicsContext3D* parent_context) {
   return false;
 }
 
 WebGLId WebGraphicsContext3DInProcessImpl::getPlatformTextureId() {
   return texture_;
 }
 
 void WebGraphicsContext3DInProcessImpl::prepareTexture() {
-  if (window_ != gfx::kNullPluginWindow) {
+  if (!gl_surface_->IsOffscreen()) {
     gl_surface_->SwapBuffers();
   } else if (!render_directly_to_web_view_) {
     // We need to prepare our rendering results for the compositor.
     makeContextCurrent();
     ResolveMultisampledFramebuffer(0, 0, cached_width_, cached_height_);
   }
 }
 
 void WebGraphicsContext3DInProcessImpl::postSubBufferCHROMIUM(
     int x, int y, int width, int height) {
@@ skipping 13 matching lines @@
 }
 
 }  // anonymous namespace
 
 void WebGraphicsContext3DInProcessImpl::reshape(int width, int height) {
   cached_width_ = width;
   cached_height_ = height;
   makeContextCurrent();
 
   bool must_restore_fbo = false;
-  if (window_ == gfx::kNullPluginWindow)
+  if (gl_surface_->IsOffscreen())
     must_restore_fbo = AllocateOffscreenFrameBuffer(width, height);
 
   gl_surface_->Resize(gfx::Size(width, height));
   ClearRenderTarget();
 
   if (must_restore_fbo)
     glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, bound_fbo_);
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
   if (scanline_) {
@@ skipping 1330 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