Implemented Browser Plugin (NOT FOR REVIEW)

content/renderer/gpu/webgraphicscontext3d_guest.h

 // 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.
 
-#ifndef CONTENT_COMMON_GPU_CLIENT_WEBGRAPHICSCONTEXT3D_COMMAND_BUFFER_IMPL_H_
-#define CONTENT_COMMON_GPU_CLIENT_WEBGRAPHICSCONTEXT3D_COMMAND_BUFFER_IMPL_H_
+#ifndef CONTENT_RENDERER_GPU_WEBGRAPHICSCONTEXT3D_GUEST_H_
+#define CONTENT_RENDERER_GPU_WEBGRAPHICSCONTEXT3D_GUEST_H_
 #pragma once
 
+#if defined(ENABLE_GPU)
+
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "content/common/gpu/client/content_gl_context.h"
 #include "googleurl/src/gurl.h"
+#include "gpu/command_buffer/client/gles2_cmd_helper.h"
+#include "gpu/command_buffer/client/gles2_implementation.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebGraphicsContext3D.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/gpu_preference.h"
 #include "ui/gfx/native_widget_types.h"
 
 #if defined(USE_SKIA)
 #define FLIP_FRAMEBUFFER_VERTICALLY
 #endif
 
 class GpuChannelHost;
+class GuestToHostChannel;
 
 namespace gpu {
+class TransferBuffer;
 namespace gles2 {
 class GLES2Implementation;
 }
 }
 
 using WebKit::WebGLId;
 
 using WebKit::WGC3Dchar;
 using WebKit::WGC3Denum;
 using WebKit::WGC3Dboolean;
 using WebKit::WGC3Dbitfield;
 using WebKit::WGC3Dint;
 using WebKit::WGC3Dsizei;
 using WebKit::WGC3Duint;
 using WebKit::WGC3Dfloat;
 using WebKit::WGC3Dclampf;
 using WebKit::WGC3Dintptr;
 using WebKit::WGC3Dsizeiptr;
 
-// TODO(piman): move this logic to the compositor and remove it from the
-// context...
-class WebGraphicsContext3DSwapBuffersClient {
- public:
-  virtual ~WebGraphicsContext3DSwapBuffersClient() { }
-  virtual void OnViewContextSwapBuffersPosted() = 0;
-  virtual void OnViewContextSwapBuffersComplete() = 0;
-  virtual void OnViewContextSwapBuffersAborted() = 0;
-};
-
-class WebGraphicsContext3DCommandBufferImpl
+class WebGraphicsContext3DGuest
     : public WebKit::WebGraphicsContext3D {
  public:
-  WebGraphicsContext3DCommandBufferImpl(
-      int surface_id,
-      const GURL& active_url,
-      const base::WeakPtr<WebGraphicsContext3DSwapBuffersClient>& swap_client);
-  virtual ~WebGraphicsContext3DCommandBufferImpl();
-
-  bool Initialize(const Attributes& attributes);
+  static const int32 kCommandBufferSize = 1024 * 1024;
+  static const int32 kTransferBufferSize = 1024 * 1024;
+  WebGraphicsContext3DGuest(gpu::CommandBuffer* command_buffer,
+                            GuestToHostChannel* channel,
+                            WebKit::WebView* webview);
+  virtual ~WebGraphicsContext3DGuest();
 
   //----------------------------------------------------------------------
   // WebGraphicsContext3D methods
 
-  // Must be called after initialize() and before any of the following methods.
   // Permanently binds to the first calling thread. Returns false if the
   // graphics context fails to create. Do not call from more than one thread.
   virtual bool makeContextCurrent();
 
   virtual int width();
   virtual int height();
 
+  virtual void playDead();
+
   virtual bool isGLES2Compliant();
 
   virtual bool setParentContext(WebGraphicsContext3D* parent_context);
 
   virtual void reshape(int width, int height);
 
   virtual bool readBackFramebuffer(unsigned char* pixels, size_t buffer_size);
   virtual bool readBackFramebuffer(unsigned char* pixels, size_t buffer_size,
                                    WebGLId framebuffer, int width, int height);
 
@@ skipping 342 matching lines @@
       WGC3Dint yoffset,
       WGC3Dsizei width,
       WGC3Dsizei height,
       WGC3Denum format,
       WGC3Denum type,
       WGC3Denum access);
   virtual void unmapTexSubImage2DCHROMIUM(const void*);
 
   virtual void setVisibilityCHROMIUM(bool visible);
 
-  virtual void setMemoryAllocationChangedCallbackCHROMIUM(
-      WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback);
-
   virtual void copyTextureToParentTextureCHROMIUM(
       WebGLId texture, WebGLId parentTexture);
 
   virtual void rateLimitOffscreenContextCHROMIUM();
 
   virtual WebKit::WebString getRequestableExtensionsCHROMIUM();
   virtual void requestExtensionCHROMIUM(const char*);
 
   virtual void blitFramebufferCHROMIUM(
       WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,
       WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,
       WGC3Dbitfield mask, WGC3Denum filter);
   virtual void renderbufferStorageMultisampleCHROMIUM(
       WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,
       WGC3Dsizei width, WGC3Dsizei height);
 
   virtual WebKit::WebString getTranslatedShaderSourceANGLE(WebGLId shader);
 
-  ContentGLContext* context() { return context_; }
-
   virtual void setContextLostCallback(
       WebGraphicsContext3D::WebGraphicsContextLostCallback* callback);
   virtual WGC3Denum getGraphicsResetStatusARB();
 
-  virtual void setErrorMessageCallback(
-      WebGraphicsContext3D::WebGraphicsErrorMessageCallback* callback);
-
   virtual void setSwapBuffersCompleteCallbackCHROMIUM(
       WebGraphicsContext3D::
           WebGraphicsSwapBuffersCompleteCallbackCHROMIUM* callback);
 
   virtual void texImageIOSurface2DCHROMIUM(
       WGC3Denum target, WGC3Dint width, WGC3Dint height,
       WGC3Duint ioSurfaceId, WGC3Duint plane);
 
   virtual void texStorage2DEXT(
       WGC3Denum target, WGC3Dint levels, WGC3Duint internalformat,
       WGC3Dint width, WGC3Dint height);
 
-  ContentGLContext* content_gl_context() const { return context_; }
-
- protected:
-#if WEBKIT_USING_SKIA
-  virtual GrGLInterface* onCreateGrGLInterface();
-#endif
-
  private:
+  friend class GuestToHostChannel;
   // Initialize the underlying GL context. May be called multiple times; second
   // and subsequent calls are ignored. Must be called from the thread that is
   // going to use this object to issue GL commands (which might not be the main
   // thread).
   bool MaybeInitializeGL();
 
   // SwapBuffers callback.
   void OnSwapBuffersComplete();
-  virtual void OnContextLost(ContentGLContext::ContextLostReason reason);
-  virtual void OnErrorMessage(const std::string& message, int id);
 
-  // Check if we should call into the swap client. We can only do that on the
-  // main thread.
-  bool ShouldUseSwapClient();
-
-  // MemoryAllocationChanged callback.
-  void OnMemoryAllocationChanged(const GpuMemoryAllocation& allocation);
+  GuestToHostChannel* channel_;
 
   bool initialize_failed_;
 
-  // The context we use for OpenGL rendering.
-  ContentGLContext* context_;
-  // The GLES2Implementation we use for OpenGL rendering.
-  gpu::gles2::GLES2Implementation* gl_;
+  // State needed by MaybeInitializeGL.
+  bool render_directly_to_web_view_;
 
-  // State needed by MaybeInitializeGL.
-  GpuChannelHost* host_;
-  int32 surface_id_;
-  GURL active_url_;
-  base::WeakPtr<WebGraphicsContext3DSwapBuffersClient> swap_client_;
+  // Context Lost
+  void OnContextLost();
 
-  WebGraphicsMemoryAllocationChangedCallbackCHROMIUM*
-      memory_allocation_changed_callback_;
+  // If rendering directly to WebView, weak pointer to it.
+  // This is only set when the context is bound to the main thread.
+  WebKit::WebView* web_view_;
 
   WebGraphicsContext3D::WebGraphicsContextLostCallback* context_lost_callback_;
   WGC3Denum context_lost_reason_;
 
-  WebGraphicsContext3D::WebGraphicsErrorMessageCallback*
-      error_message_callback_;
-
   WebGraphicsContext3D::WebGraphicsSwapBuffersCompleteCallbackCHROMIUM*
       swapbuffers_complete_callback_;
 
   WebKit::WebGraphicsContext3D::Attributes attributes_;
-  gfx::GpuPreference gpu_preference_;
   int cached_width_, cached_height_;
+  bool dead_;
 
   // For tracking which FBO is bound.
   WebGLId bound_fbo_;
 
   // Errors raised by synthesizeGLError().
   std::vector<WGC3Denum> synthetic_errors_;
 
-  base::WeakPtrFactory<WebGraphicsContext3DCommandBufferImpl> weak_ptr_factory_;
+  scoped_ptr<gpu::CommandBuffer> command_buffer_;
+
+  scoped_ptr<gpu::gles2::GLES2CmdHelper> gles2_helper_;
+
+  scoped_ptr<gpu::TransferBuffer> transfer_buffer_;
+
+  scoped_ptr<gpu::gles2::GLES2Implementation> gl_;
+
+  base::WeakPtrFactory<WebGraphicsContext3DGuest> weak_ptr_factory_;
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
-  std::vector<uint8> scanline_;
+  scoped_array<uint8> scanline_;
   void FlipVertically(uint8* framebuffer,
                       unsigned int width,
                       unsigned int height);
 #endif
+
 };
 
-#endif  // CONTENT_COMMON_GPU_CLIENT_WEBGRAPHICSCONTEXT3D_COMMAND_BUFFER_IMPL_H_
+#endif  // defined(ENABLE_GPU)
+#endif  // CONTENT_RENDERER_GPU_WEBGRAPHICSCONTEXT3D_GUEST_H_