Integrated Pepper3D v2 with the accelerated compositor....

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/ref_counted.h"
 #include "base/singleton.h"
-#include "base/thread_local.h"
 #include "base/weak_ptr.h"
 #include "chrome/renderer/command_buffer_proxy.h"
 #include "chrome/renderer/ggl/ggl.h"
 #include "chrome/renderer/gpu_channel_host.h"
 #include "chrome/renderer/gpu_video_service_host.h"
 #include "chrome/renderer/media/gles2_video_decode_context.h"
 #include "chrome/renderer/render_widget.h"
 #include "ipc/ipc_channel_handle.h"
 
 #if defined(ENABLE_GPU)
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/GLES2/gles2_command_buffer.h"
 #endif  // ENABLE_GPU
 
 namespace ggl {
 
 #if defined(ENABLE_GPU)
 
 namespace {
 
 const int32 kCommandBufferSize = 1024 * 1024;
 // TODO(kbr): make the transfer buffer size configurable via context
 // creation attributes.
 const int32 kTransferBufferSize = 1024 * 1024;
 
-base::ThreadLocalPointer<Context> g_current_context;
-
 // Singleton used to initialize and terminate the gles2 library.
 class GLES2Initializer {
  public:
   GLES2Initializer() {
     gles2::Initialize();
   }
 
   ~GLES2Initializer() {
     gles2::Terminate();
   }
@@ skipping 20 matching lines @@
 #if defined(OS_MACOSX)
   // Asynchronously resizes an onscreen frame buffer.
   void ResizeOnscreen(const gfx::Size& size);
 #endif
 
   // Asynchronously resizes an offscreen frame buffer.
   void ResizeOffscreen(const gfx::Size& size);
 
   // Provides a callback that will be invoked when SwapBuffers has completed
   // service side.
-  void SetSwapBuffersCallback(Callback1<Context*>::Type* callback) {
+  void SetSwapBuffersCallback(Callback0::Type* callback) {
     swap_buffers_callback_.reset(callback);
   }
 
   // For an offscreen frame buffer context, return the frame buffer ID with
   // respect to the parent.
   uint32 parent_texture_id() const {
     return parent_texture_id_;
   }
 
   uint32 CreateParentTexture(const gfx::Size& size) const;
@@ skipping 19 matching lines @@
 
   // Get the current error code.  Clears context's error code afterwards.
   Error GetError();
 
   // Replace the current error code with this.
   void SetError(Error error);
 
   // TODO(gman): Remove this.
   void DisableShaderTranslation();
 
+  gpu::gles2::GLES2Implementation* gles2_implementation() const {
+    return gles2_implementation_;
+  }
  private:
   void OnSwapBuffers();
 
   scoped_refptr<GpuChannelHost> channel_;
   base::WeakPtr<Context> parent_;
-  scoped_ptr<Callback1<Context*>::Type> swap_buffers_callback_;
+  scoped_ptr<Callback0::Type> swap_buffers_callback_;
   uint32 parent_texture_id_;
   CommandBufferProxy* command_buffer_;
   gpu::gles2::GLES2CmdHelper* gles2_helper_;
   int32 transfer_buffer_id_;
   gpu::gles2::GLES2Implementation* gles2_implementation_;
+  gfx::Size size_;
+
   Error last_error_;
 
   DISALLOW_COPY_AND_ASSIGN(Context);
 };
 
 Context::Context(GpuChannelHost* channel, Context* parent)
     : channel_(channel),
       parent_(parent ? parent->AsWeakPtr() : base::WeakPtr<Context>()),
       parent_texture_id_(0),
       command_buffer_(NULL),
@@ skipping 114 matching lines @@
   }
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_ = new gpu::gles2::GLES2Implementation(
       gles2_helper_,
       transfer_buffer.size,
       transfer_buffer.ptr,
       transfer_buffer_id_,
       false);
 
+  size_ = size;
+
   return true;
 }
 
 #if defined(OS_MACOSX)
 void Context::ResizeOnscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
+  size_ = size;
   command_buffer_->SetWindowSize(size);
 }
 #endif
 
 void Context::ResizeOffscreen(const gfx::Size& size) {
   DCHECK(size.width() > 0 && size.height() > 0);
-  command_buffer_->ResizeOffscreenFrameBuffer(size);
+  if (size_ != size) {
+    command_buffer_->ResizeOffscreenFrameBuffer(size);
+    size_ = size;
+  }
 }
 
 uint32 Context::CreateParentTexture(const gfx::Size& size) const {
   // Allocate a texture ID with respect to the parent.
   if (parent_.get()) {
     if (!MakeCurrent(parent_.get()))
       return 0;
     uint32 texture_id = parent_->gles2_implementation_->MakeTextureId();
     parent_->gles2_implementation_->BindTexture(GL_TEXTURE_2D, texture_id);
     parent_->gles2_implementation_->TexParameteri(
@@ skipping 48 matching lines @@
 
   if (channel_ && command_buffer_) {
     channel_->DestroyCommandBuffer(command_buffer_);
     command_buffer_ = NULL;
   }
 
   channel_ = NULL;
 }
 
 bool Context::MakeCurrent(Context* context) {
-  g_current_context.Set(context);
   if (context) {
     gles2::SetGLContext(context->gles2_implementation_);
 
     // Don't request latest error status from service. Just use the locally
     // cached information from the last flush.
     // TODO(apatrick): I'm not sure if this should actually change the
     // current context if it fails. For now it gets changed even if it fails
     // because making GL calls with a NULL context crashes.
     if (context->command_buffer_->GetLastState().error != gpu::error::kNoError)
       return false;
@@ skipping 41 matching lines @@
   last_error_ = error;
 }
 
 // TODO(gman): Remove This
 void Context::DisableShaderTranslation() {
   gles2_implementation_->CommandBufferEnable(PEPPER3D_SKIP_GLSL_TRANSLATION);
 }
 
 void Context::OnSwapBuffers() {
   if (swap_buffers_callback_.get())
-    swap_buffers_callback_->Run(this);
+    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)
@@ skipping 54 matching lines @@
 #endif
 }
 
 void DeleteParentTexture(Context* context, uint32 texture) {
 #if defined(ENABLE_GPU)
   context->DeleteParentTexture(texture);
 #endif
 }
 
 void SetSwapBuffersCallback(Context* context,
-                            Callback1<Context*>::Type* callback) {
+                            Callback0::Type* callback) {
 #if defined(ENABLE_GPU)
   context->SetSwapBuffersCallback(callback);
 #endif
 }
 
 bool MakeCurrent(Context* context) {
 #if defined(ENABLE_GPU)
   return Context::MakeCurrent(context);
 #else
   return false;
 #endif
 }
 
-Context* GetCurrentContext() {
-#if defined(ENABLE_GPU)
-  return g_current_context.Get();
-#else
-  return NULL;
-#endif
-}
-
 bool SwapBuffers(Context* context) {
 #if defined(ENABLE_GPU)
   if (!context)
     return false;
 
   return context->SwapBuffers();
 #else
   return false;
 #endif
 }
 
 bool DestroyContext(Context* context) {
 #if defined(ENABLE_GPU)
   if (!context)
     return false;
 
-  if (context == GetCurrentContext())
-    MakeCurrent(NULL);
-
   delete context;
   return true;
 #else
   return false;
 #endif
 }
 
 media::VideoDecodeEngine* CreateVideoDecodeEngine(Context* context) {
   return context->CreateVideoDecodeEngine();
 }
 
 media::VideoDecodeContext* CreateVideoDecodeContext(
     Context* context, MessageLoop* message_loop, bool hardware_decoder) {
   return context->CreateVideoDecodeContext(message_loop, hardware_decoder);
 }
 
-Error GetError() {
+Error GetError(Context* context) {
 #if defined(ENABLE_GPU)
-  Context* context = GetCurrentContext();
-  if (!context)
-    return BAD_CONTEXT;
-
   return context->GetError();
 #else
   return NOT_INITIALIZED;
 #endif
 }
 
 // TODO(gman): Remove This
 void DisableShaderTranslation(Context* context) {
 #if defined(ENABLE_GPU)
   if (context) {
     context->DisableShaderTranslation();
   }
 #endif
 }
+
+gpu::gles2::GLES2Implementation* GetImplementation(Context* context) {
+  if (!context)
+    return NULL;
+
+  return context->gles2_implementation();
+}
+
 }  // namespace ggl