Added Pepper 3D render context that instantiates the GPU plugin....

chrome/renderer/webplugin_delegate_pepper.cc

 // Copyright (c) 2009 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.
 
 #define PEPPER_APIS_ENABLED 1
 
 #include "chrome/renderer/webplugin_delegate_pepper.h"
 
 #include <string>
 #include <vector>
 
 #include "app/gfx/blit.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/render_thread.h"
+#include "chrome/renderer/webplugin_delegate_proxy.h"
 #include "third_party/npapi/bindings/npapi_extensions.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebInputEvent.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/plugins/plugin_constants_win.h"
 #include "webkit/glue/plugins/plugin_instance.h"
 #include "webkit/glue/plugins/plugin_lib.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/plugins/plugin_stream_url.h"
 #include "webkit/glue/webkit_glue.h"
 
+#if defined(ENABLE_GPU)
+#include "webkit/glue/plugins/plugin_constants_win.h"
+#endif
+
+using gpu::Buffer;
 using webkit_glue::WebPlugin;
 using webkit_glue::WebPluginDelegate;
 using webkit_glue::WebPluginResourceClient;
 using WebKit::WebCursorInfo;
 using WebKit::WebKeyboardEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
 
 namespace {
 
 const uint32 kBytesPerPixel = 4;  // Only 8888 RGBA for now.
 
 }  // namespace
 
 // Implementation artifacts for a context
 struct Device2DImpl {
   TransportDIB* dib;
 };
 
 uint32 WebPluginDelegatePepper::next_buffer_id = 0;
 
 WebPluginDelegatePepper* WebPluginDelegatePepper::Create(
     const FilePath& filename,
     const std::string& mime_type,
+    const base::WeakPtr<RenderView>& render_view,
     gfx::PluginWindowHandle containing_view) {
   scoped_refptr<NPAPI::PluginLib> plugin_lib =
       NPAPI::PluginLib::CreatePluginLib(filename);
   if (plugin_lib.get() == NULL)
     return NULL;
 
   NPError err = plugin_lib->NP_Initialize();
   if (err != NPERR_NO_ERROR)
     return NULL;
 
   scoped_refptr<NPAPI::PluginInstance> instance =
       plugin_lib->CreateInstance(mime_type);
-  return new WebPluginDelegatePepper(containing_view, instance.get());
+  return new WebPluginDelegatePepper(render_view,
+                                     containing_view,
+                                     instance.get());
 }
 
 bool WebPluginDelegatePepper::Initialize(
     const GURL& url,
     const std::vector<std::string>& arg_names,
     const std::vector<std::string>& arg_values,
     WebPlugin* plugin,
     bool load_manually) {
   plugin_ = plugin;
 
@@ skipping 12 matching lines @@
   if (!start_result)
     return false;
 
   // For windowless plugins we should set the containing window handle
   // as the instance window handle. This is what Safari does. Not having
   // a valid window handle causes subtle bugs with plugins which retreive
   // the window handle and validate the same. The window handle can be
   // retreived via NPN_GetValue of NPNVnetscapeWindow.
   instance_->set_window_handle(parent_);
 
-  // This is a windowless plugin, so set it to have a NULL handle.
-  plugin_->SetWindow(NULL);
-
   plugin_url_ = url.spec();
 
   return true;
 }
 
 void WebPluginDelegatePepper::DestroyInstance() {
   if (instance_ && (instance_->npp()->ndata != NULL)) {
     // Shutdown all streams before destroying so that
     // no streams are left "in progress".  Need to do
     // this before calling set_web_plugin(NULL) because the
@@ skipping 26 matching lines @@
   window_rect_ = window_rect;
 
   // TODO(brettw) figure out how to tell the plugin that the size changed and it
   // needs to repaint?
   SkBitmap new_committed;
   new_committed.setConfig(SkBitmap::kARGB_8888_Config,
                           window_rect_.width(), window_rect.height());
   new_committed.allocPixels();
   committed_bitmap_ = new_committed;
 
+  // Forward the new geometry to the nested plugin instance.
+  if (nested_delegate_)
+    nested_delegate_->UpdateGeometry(window_rect, clip_rect);
+
   if (!instance())
     return;
 
   // TODO(sehr): do we need all this?
   window_.clipRect.top = clip_rect_.y();
   window_.clipRect.left = clip_rect_.x();
   window_.clipRect.bottom = clip_rect_.y() + clip_rect_.height();
   window_.clipRect.right = clip_rect_.x() + clip_rect_.width();
   window_.height = window_rect_.height();
   window_.width = window_rect_.width();
@@ skipping 80 matching lines @@
 
 NPError WebPluginDelegatePepper::Device2DQueryConfig(
     const NPDeviceContext2DConfig* request,
     NPDeviceContext2DConfig* obtain) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device2DInitializeContext(
     const NPDeviceContext2DConfig* config,
     NPDeviceContext2D* context) {
+  // This is a windowless plugin, so set it to have a NULL handle. Defer this
+  // until we know the plugin will use the 2D device. If it uses the 3D device
+  // it will have a window handle.
+  plugin_->SetWindow(NULL);
+
   int width = window_rect_.width();
   int height = window_rect_.height();
   uint32 buffer_size = width * height * kBytesPerPixel;
 
   // Initialize the impelementation information in case of failure.
   context->reserved = NULL;
 
   // Allocate the transport DIB and the PlatformCanvas pointing to it.
   scoped_ptr<OpenPaintContext> paint_context(new OpenPaintContext);
   paint_context->transport_dib.reset(
@@ skipping 125 matching lines @@
 
 NPError WebPluginDelegatePepper::Device3DQueryConfig(
     const NPDeviceContext3DConfig* request,
     NPDeviceContext3DConfig* obtain) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DInitializeContext(
     const NPDeviceContext3DConfig* config,
     NPDeviceContext3D* context) {
+#if defined(ENABLE_GPU)
+  // Check to see if the GPU plugin is already initialized and fail if so.
+  if (nested_delegate_)
+    return NPERR_GENERIC_ERROR;
+
+  // Create an instance of the GPU plugin that is responsible for 3D
+  // rendering.
+  nested_delegate_ = new WebPluginDelegateProxy(kGPUPluginMimeType,
+                                                render_view_);
+
+  // TODO(apatrick): should the GPU plugin be attached to plugin_?
+  if (nested_delegate_->Initialize(GURL(),
+                                   std::vector<std::string>(),
+                                   std::vector<std::string>(),
+                                   plugin_,
+                                   false)) {
+    // Ask the GPU plugin to create a command buffer and return a proxy.
+    command_buffer_.reset(nested_delegate_->CreateCommandBuffer());
+    if (command_buffer_.get()) {
+      // Initialize the proxy command buffer.
+      if (command_buffer_->Initialize(config->commandBufferEntries)) {
+        // Initialize the 3D context.
+        context->reserved = NULL;
+        Buffer ring_buffer = command_buffer_->GetRingBuffer();
+        context->commandBuffer = ring_buffer.ptr;
+        context->commandBufferEntries = command_buffer_->GetSize();
+        context->getOffset = command_buffer_->GetGetOffset();
+        context->putOffset = command_buffer_->GetPutOffset();
+
+        // Ensure the service knows the window size before rendering anything.
+        nested_delegate_->UpdateGeometry(window_rect_, clip_rect_);
+
+        return NPERR_NO_ERROR;
+      }
+    }
+
+    command_buffer_.reset();
+  }
+
+  nested_delegate_->PluginDestroyed();
+  nested_delegate_ = NULL;
+#endif  // ENABLE_GPU
+
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DSetStateContext(
     NPDeviceContext3D* context,
     int32 state,
     int32 value) {
   return NPERR_GENERIC_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DGetStateContext(
     NPDeviceContext3D* context,
     int32 state,
     int32* value) {
-  return NPERR_GENERIC_ERROR;
+#if defined(ENABLE_GPU)
+  if (!command_buffer_.get())
+    return NPERR_GENERIC_ERROR;
+
+  switch (state) {
+    case NPDeviceContext3DState_GetOffset:
+      context->getOffset = *value = command_buffer_->GetGetOffset();
+      break;
+    case NPDeviceContext3DState_PutOffset:
+      *value = command_buffer_->GetPutOffset();
+      break;
+    case NPDeviceContext3DState_Token:
+      *value = command_buffer_->GetToken();
+      break;
+    case NPDeviceContext3DState_ParseError:
+      *value = command_buffer_->ResetParseError();
+      break;
+    case NPDeviceContext3DState_ErrorStatus:
+      *value = command_buffer_->GetErrorStatus() ? 1 : 0;
+      break;
+    default:
+      return NPERR_GENERIC_ERROR;
+  };
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DFlushContext(
     NPP id,
     NPDeviceContext3D* context,
     NPDeviceFlushContextCallbackPtr callback,
     void* user_data) {
-  return NPERR_GENERIC_ERROR;
+#if defined(ENABLE_GPU)
+  DCHECK(callback == NULL);
+  context->getOffset = command_buffer_->SyncOffsets(context->putOffset);
+#endif  // ENABLE_GPU
+  return NPERR_NO_ERROR;
 }
 
 NPError WebPluginDelegatePepper::Device3DDestroyContext(
     NPDeviceContext3D* context) {
-  return NPERR_GENERIC_ERROR;
+#if defined(ENABLE_GPU)
+  command_buffer_.reset();
+
+  if (nested_delegate_) {
+    nested_delegate_->PluginDestroyed();
+    nested_delegate_ = NULL;
+  }
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
-bool WebPluginDelegatePepper::IsPluginDelegateWindow(
-    gfx::NativeWindow window) {
-  return false;
+NPError WebPluginDelegatePepper::Device3DCreateBuffer(
+    NPDeviceContext3D* context,
+    size_t size,
+    int32* id) {
+#if defined(ENABLE_GPU)
+  *id = command_buffer_->CreateTransferBuffer(size);
+  if (*id < 0)
+    return NPERR_GENERIC_ERROR;
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
-bool WebPluginDelegatePepper::GetPluginNameFromWindow(
-    gfx::NativeWindow window, std::wstring *plugin_name) {
-  return false;
+NPError WebPluginDelegatePepper::Device3DDestroyBuffer(
+    NPDeviceContext3D* context,
+    int32 id) {
+#if defined(ENABLE_GPU)
+  command_buffer_->DestroyTransferBuffer(id);
+#endif  // ENABLE_GPU
+  return NPERR_NO_ERROR;
 }
 
-bool WebPluginDelegatePepper::IsDummyActivationWindow(
-    gfx::NativeWindow window) {
-  return false;
+NPError WebPluginDelegatePepper::Device3DMapBuffer(
+    NPDeviceContext3D* context,
+    int32 id,
+    NPDeviceBuffer* np_buffer) {
+#if defined(ENABLE_GPU)
+  Buffer gpu_buffer = command_buffer_->GetTransferBuffer(id);
+  np_buffer->ptr = gpu_buffer.ptr;
+  np_buffer->size = gpu_buffer.size;
+  if (!np_buffer->ptr)
+    return NPERR_GENERIC_ERROR;
+#endif  // ENABLE_GPU
+
+  return NPERR_NO_ERROR;
 }
 
 WebPluginDelegatePepper::WebPluginDelegatePepper(
+    const base::WeakPtr<RenderView>& render_view,
     gfx::PluginWindowHandle containing_view,
     NPAPI::PluginInstance *instance)
-    : plugin_(NULL),
+    : render_view_(render_view),
+      plugin_(NULL),
       instance_(instance),
       parent_(containing_view),
       buffer_size_(0),
-      plugin_buffer_(0) {
+      plugin_buffer_(0),
+      nested_delegate_(NULL) {
   // For now we keep a window struct, although it isn't used.
   memset(&window_, 0, sizeof(window_));
   // All Pepper plugins are windowless and transparent.
   // TODO(sehr): disable resetting these NPPVs by plugins.
   instance->set_windowless(true);
   instance->set_transparent(true);
 }
 
 WebPluginDelegatePepper::~WebPluginDelegatePepper() {
   DestroyInstance();
 }
 
 void WebPluginDelegatePepper::PluginDestroyed() {
+  if (nested_delegate_) {
+    nested_delegate_->PluginDestroyed();
+    nested_delegate_ = NULL;
+  }
   delete this;
 }
 
 void WebPluginDelegatePepper::Paint(WebKit::WebCanvas* canvas,
                                     const gfx::Rect& rect) {
 #if defined(OS_WIN)
-  // Blit from background_context to context.
-  if (!committed_bitmap_.isNull()) {
-    gfx::Point origin(window_rect_.origin().x(), window_rect_.origin().y());
-    canvas->drawBitmap(committed_bitmap_,
-                       SkIntToScalar(window_rect_.origin().x()),
-                       SkIntToScalar(window_rect_.origin().y()));
+  if (nested_delegate_) {
+    // TODO(apatrick): The GPU plugin will render to an offscreen render target.
+    //    Need to copy it to the screen here.
+  } else {
+    // Blit from background_context to context.
+    if (!committed_bitmap_.isNull()) {
+      gfx::Point origin(window_rect_.origin().x(), window_rect_.origin().y());
+      canvas->drawBitmap(committed_bitmap_,
+                         SkIntToScalar(window_rect_.origin().x()),
+                         SkIntToScalar(window_rect_.origin().y()));
+    }
   }
 #endif
 }
 
 void WebPluginDelegatePepper::Print(gfx::NativeDrawingContext context) {
   NOTIMPLEMENTED();
 }
 
 void WebPluginDelegatePepper::InstallMissingPlugin() {
   NOTIMPLEMENTED();
@@ skipping 113 matching lines @@
       BuildCharEvent(&event, &npevent);
       break;
     case NPEventType_Minimize:
     case NPEventType_Focus:
     case NPEventType_Device:
       // NOTIMPLEMENTED();
       break;
   }
   return instance()->NPP_HandleEvent(&npevent) != 0;
 }