Route IPC through browser when creating a viewable command buffer.

chrome/renderer/ggl/ggl.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include "base/lazy_instance.h"
 #include "base/ref_counted.h"
 #include "base/weak_ptr.h"
 #include "chrome/renderer/command_buffer_proxy.h"
@@ skipping 44 matching lines @@
 }  // namespace anonymous
 
 // Manages a GL context.
 class Context : public base::SupportsWeakPtr<Context> {
  public:
   Context(GpuChannelHost* channel, Context* parent);
   ~Context();
 
   // Initialize a GGL context that can be used in association with a a GPU
   // channel acquired from a RenderWidget or RenderView.
-  bool Initialize(gfx::NativeViewId view,
+  bool Initialize(bool onscreen,
                   int render_view_id,
                   const gfx::Size& size,
                   const char* allowed_extensions,
                   const int32* attrib_list);
 
 #if defined(OS_MACOSX)
   // Asynchronously resizes an onscreen frame buffer.
   void ResizeOnscreen(const gfx::Size& size);
 #endif
 
@@ skipping 73 matching lines @@
       transfer_buffer_id_(0),
       gles2_implementation_(NULL),
       last_error_(SUCCESS) {
   DCHECK(channel);
 }
 
 Context::~Context() {
   Destroy();
 }
 
-bool Context::Initialize(gfx::NativeViewId view,
+bool Context::Initialize(bool onscreen,
                          int render_view_id,
                          const gfx::Size& size,
                          const char* allowed_extensions,
                          const int32* attrib_list) {
   DCHECK(size.width() >= 0 && size.height() >= 0);
 
   if (channel_->state() != GpuChannelHost::kConnected)
     return false;
 
   // Ensure the gles2 library is initialized first in a thread safe way.
@@ skipping 30 matching lines @@
         break;
       default:
         SetError(ggl::BAD_ATTRIBUTE);
         attribs.push_back(ggl::GGL_NONE);
         attrib_list = NULL;
         break;
     }
   }
 
   // Create a proxy to a command buffer in the GPU process.
-  if (view) {
+  if (onscreen) {
     command_buffer_ = channel_->CreateViewCommandBuffer(
-        view,
         render_view_id,
         allowed_extensions,
         attribs);
   } else {
     CommandBufferProxy* parent_command_buffer =
         parent_.get() ? parent_->command_buffer_ : NULL;
     command_buffer_ = channel_->CreateOffscreenCommandBuffer(
         parent_command_buffer,
         size,
         allowed_extensions,
@@ skipping 204 matching lines @@
 }
 
 void Context::OnSwapBuffers() {
   if (swap_buffers_callback_.get())
     swap_buffers_callback_->Run();
 }
 
 #endif  // ENABLE_GPU
 
 Context* CreateViewContext(GpuChannelHost* channel,
-                           gfx::NativeViewId view,
                            int render_view_id,
                            const char* allowed_extensions,
                            const int32* attrib_list) {
 #if defined(ENABLE_GPU)
   scoped_ptr<Context> context(new Context(channel, NULL));
   if (!context->Initialize(
-      view, render_view_id, gfx::Size(), allowed_extensions, attrib_list))
+      true, render_view_id, gfx::Size(), allowed_extensions, attrib_list))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 #if defined(OS_MACOSX)
 void ResizeOnscreenContext(Context* context, const gfx::Size& size) {
 #if defined(ENABLE_GPU)
   context->ResizeOnscreen(size);
 #endif
 }
 #endif
 
 Context* CreateOffscreenContext(GpuChannelHost* channel,
                                 Context* parent,
                                 const gfx::Size& size,
                                 const char* allowed_extensions,
                                 const int32* attrib_list) {
 #if defined(ENABLE_GPU)
   scoped_ptr<Context> context(new Context(channel, parent));
-  if (!context->Initialize(0, 0, size, allowed_extensions, attrib_list))
+  if (!context->Initialize(false, 0, size, allowed_extensions, attrib_list))
     return NULL;
 
   return context.release();
 #else
   return NULL;
 #endif
 }
 
 void ResizeOffscreenContext(Context* context, const gfx::Size& size) {
 #if defined(ENABLE_GPU)
@@ skipping 92 matching lines @@
 }
 
 gpu::gles2::GLES2Implementation* GetImplementation(Context* context) {
   if (!context)
     return NULL;
 
   return context->gles2_implementation();
 }
 
 }  // namespace ggl