Add create WGC3DInProcessCommandBuffer for on-screen context

webkit/gpu/webgraphicscontext3d_in_process_command_buffer_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_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 71 matching lines @@
 
   // Terminate the library. This must be called after any other functions
   // have completed.
   static bool Terminate();
 
   ~GLInProcessContext();
 
   void PumpCommands();
   bool GetBufferChanged(int32 transfer_buffer_id);
 
-  // Create a GLInProcessContext that renders to an offscreen frame buffer. If
-  // parent is not NULL, that GLInProcessContext can access a copy of the
-  // created GLInProcessContext's frame buffer that is updated every time
-  // SwapBuffers is called. It is not as general as shared GLInProcessContexts
-  // in other implementations of OpenGL. If parent is not NULL, it must be used
-  // on the same thread as the parent. A child GLInProcessContext may not
-  // outlive its parent.  attrib_list must be NULL or a NONE-terminated list of
-  // attribute/value pairs.
-  static GLInProcessContext* CreateOffscreenContext(
+  // Create a GLInProcessContext, if |is_offscreen| is true, renders to an
+  // offscreen context. If parent is not NULL, that GLInProcessContext can

[jamesr, 2013/04/19 00:52:28]

since you're updating this comment anyway, can you delete the 'parent/child'
stuff?  That isn't true (and hasn't been true in months).

[boliu, 2013/04/19 00:57:31]

That's most of this block of comment. Done.

+  // access a copy of the created GLInProcessContext's frame buffer that is
+  // updated every time SwapBuffers is called. It is not as general as shared
+  // GLInProcessContexts in other implementations of OpenGL. If parent is not
+  // NULL, it must be used on the same thread as the parent. A child
+  // GLInProcessContext may not outlive its parent.  attrib_list must be NULL
+  // or a NONE-terminated list of attribute/value pairs.
+  static GLInProcessContext* CreateContext(
+      bool is_offscreen,
+      gfx::AcceleratedWidget window,
       const gfx::Size& size,
       bool share_resources,
       const char* allowed_extensions,
       const int32* attrib_list,
       gfx::GpuPreference gpu_preference);
 
   // For an offscreen frame buffer GLInProcessContext, return the texture ID
   // with respect to the parent GLInProcessContext. Returns zero if
   // GLInProcessContext does not have a parent.
   uint32 GetParentTextureId();
@@ skipping 30 matching lines @@
   // problem communicating with the GPU process.
   bool IsCommandBufferContextLost();
 
   CommandBufferService* GetCommandBufferService();
 
   ::gpu::gles2::GLES2Decoder* GetDecoder();
 
  private:
   explicit GLInProcessContext(bool share_resources);
 
-  bool Initialize(const gfx::Size& size,
+  bool Initialize(bool is_offscreen,
+                  gfx::AcceleratedWidget window,
+                  const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list,
                   gfx::GpuPreference gpu_preference);
   void Destroy();
 
   void OnContextLost();
 
   base::Closure context_lost_callback_;
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferService> command_buffer_;
@@ skipping 39 matching lines @@
 
 static base::LazyInstance<GLES2Initializer> g_gles2_initializer =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace anonymous
 
 GLInProcessContext::~GLInProcessContext() {
   Destroy();
 }
 
-GLInProcessContext* GLInProcessContext::CreateOffscreenContext(
+GLInProcessContext* GLInProcessContext::CreateContext(
+    bool is_offscreen,
+    gfx::AcceleratedWidget window,
     const gfx::Size& size,
     bool share_resources,
     const char* allowed_extensions,
     const int32* attrib_list,
     gfx::GpuPreference gpu_preference) {
   scoped_ptr<GLInProcessContext> context(
       new GLInProcessContext(share_resources));
   if (!context->Initialize(
+      is_offscreen,
+      window,
       size,
       allowed_extensions,
       attrib_list,
       gpu_preference))
     return NULL;
 
   return context.release();
 }
 
 // In the normal command buffer implementation, all commands are passed over IPC
@@ skipping 148 matching lines @@
 GLES2Implementation* GLInProcessContext::GetImplementation() {
   return gles2_implementation_.get();
 }
 
 GLInProcessContext::GLInProcessContext(bool share_resources)
     : last_error_(SUCCESS),
       share_resources_(share_resources),
       context_lost_(false) {
 }
 
-bool GLInProcessContext::Initialize(const gfx::Size& size,
-                                    const char* allowed_extensions,
-                                    const int32* attrib_list,
-                                    gfx::GpuPreference gpu_preference) {
+bool GLInProcessContext::Initialize(
+    bool is_offscreen,
+    gfx::AcceleratedWidget window,
+    const gfx::Size& size,
+    const char* allowed_extensions,
+    const int32* attrib_list,
+    gfx::GpuPreference gpu_preference) {
   // Use one share group for all contexts.
   CR_DEFINE_STATIC_LOCAL(scoped_refptr<gfx::GLShareGroup>, share_group,
                          (new gfx::GLShareGroup));
 
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   // Ensure the gles2 library is initialized first in a thread safe way.
   g_gles2_initializer.Get();
 
   std::vector<int32> attribs;
@@ skipping 52 matching lines @@
         context_group->decoder_->GetContextGroup() :
             new ::gpu::gles2::ContextGroup(
                 NULL, NULL, NULL, bind_generates_resource)));
 
     gpu_scheduler_.reset(new GpuScheduler(command_buffer_.get(),
                                           decoder_.get(),
                                           decoder_.get()));
 
     decoder_->set_engine(gpu_scheduler_.get());
 
-    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
+    if (is_offscreen)
+      surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, size);
+    else
+      surface_ = gfx::GLSurface::CreateViewGLSurface(false, window);
 
     if (!surface_.get()) {
       LOG(ERROR) << "Could not create GLSurface.";
       Destroy();
       return false;
     }
 
     context_ = gfx::GLContext::CreateGLContext(share_group.get(),
                                                surface_.get(),
                                                gpu_preference);
@@ skipping 92 matching lines @@
   }
 
   g_all_shared_contexts.Pointer()->erase(this);
 }
 
 void GLInProcessContext::OnContextLost() {
   if (!context_lost_callback_.is_null())
     context_lost_callback_.Run();
 }
 
+
+// static
+WebGraphicsContext3DInProcessCommandBufferImpl*
+WebGraphicsContext3DInProcessCommandBufferImpl::CreateViewContext(
+    const WebKit::WebGraphicsContext3D::Attributes& attributes,
+    gfx::AcceleratedWidget window) {
+  return new WebGraphicsContext3DInProcessCommandBufferImpl(
+      attributes, false, window);
+}
+
+// static
+WebGraphicsContext3DInProcessCommandBufferImpl*
+WebGraphicsContext3DInProcessCommandBufferImpl::CreateOffscreenContext(
+    const WebKit::WebGraphicsContext3D::Attributes& attributes) {
+  return new WebGraphicsContext3DInProcessCommandBufferImpl(
+      attributes, true, gfx::kNullAcceleratedWidget);
+}
+
 WebGraphicsContext3DInProcessCommandBufferImpl::
     WebGraphicsContext3DInProcessCommandBufferImpl(
-        const WebKit::WebGraphicsContext3D::Attributes& attributes)
-    : initialized_(false),
+        const WebKit::WebGraphicsContext3D::Attributes& attributes,
+        bool is_offscreen,
+        gfx::AcceleratedWidget window)
+    : is_offscreen_(is_offscreen),
+      window_(window),
+      initialized_(false),
       initialize_failed_(false),
       context_(NULL),
       gl_(NULL),
       context_lost_callback_(NULL),
       context_lost_reason_(GL_NO_ERROR),
       attributes_(attributes),
       cached_width_(0),
       cached_height_(0),
       bound_fbo_(0) {
 }
@@ skipping 27 matching lines @@
 
   const char* preferred_extensions = "*";
 
   // TODO(kbr): More work will be needed in this implementation to
   // properly support GPU switching. Like in the out-of-process
   // command buffer implementation, all previously created contexts
   // will need to be lost either when the first context requesting the
   // discrete GPU is created, or the last one is destroyed.
   gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 
-  context_ = GLInProcessContext::CreateOffscreenContext(
+  context_ = GLInProcessContext::CreateContext(
+      is_offscreen_,
+      window_,
       gfx::Size(1, 1),
       attributes_.shareResources,
       preferred_extensions,
       attribs,
       gpu_preference);
 
   if (!context_) {
     initialize_failed_ = true;
     return false;
   }
@@ skipping 1077 matching lines @@
 
 DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
     WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei,
     WGC3Denum, WGC3Denum, const void*)
 
 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
     WGC3Denum)
 
 }  // namespace gpu
 }  // namespace webkit