3D Compositing in <browser>, first draft.

content/renderer/browser_plugin/browser_plugin.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 "content/renderer/browser_plugin/browser_plugin.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "content/common/browser_plugin_messages.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/browser_plugin/browser_plugin_bindings.h"
 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
+#include "content/renderer/browser_plugin/browser_plugin_texture_provider.h"
 #include "content/renderer/render_process_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "skia/ext/platform_canvas.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebFloatRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginParams.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
 #include "webkit/plugins/sad_plugin.h"
 
@@ skipping 20 matching lines @@
     RenderViewImpl* render_view,
     WebKit::WebFrame* frame,
     const WebPluginParams& params)
     : instance_id_(instance_id),
       render_view_(render_view),
       container_(NULL),
       damage_buffer_(NULL),
       sad_guest_(NULL),
       guest_crashed_(false),
       resize_pending_(false),
-      parent_frame_(frame->identifier()) {
+      parent_frame_(frame->identifier()),
+      provider_(0),
+      ignore_input_(false) {
   BrowserPluginManager::Get()->AddBrowserPlugin(instance_id, this);
   bindings_.reset(new BrowserPluginBindings(this));
 
   std::string src;
   if (ParseSrcAttribute(params, &src))
     SetSrcAttribute(src);
 }
 
 BrowserPlugin::~BrowserPlugin() {
   if (damage_buffer_) {
     RenderProcess::current()->FreeTransportDIB(damage_buffer_);
     damage_buffer_ = NULL;
   }
   RemoveEventListeners();
   BrowserPluginManager::Get()->RemoveBrowserPlugin(instance_id_);
   BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(
           render_view_->GetRoutingID(),
           instance_id_));
+
+  if (provider_)
+    provider_->Destroy();
 }
 
 void BrowserPlugin::Cleanup() {
   if (damage_buffer_) {
     RenderProcess::current()->FreeTransportDIB(damage_buffer_);
     damage_buffer_ = NULL;
   }
 }
 
 std::string BrowserPlugin::GetSrcAttribute() const {
   return src_;
 }
 
 void BrowserPlugin::SetSrcAttribute(const std::string& src) {
   if (src == src_ && !guest_crashed_)
     return;
   if (!src.empty()) {
+    WebKit::WebView* web_view = render_view_->webview();
+    DCHECK(web_view);
+    WebGraphicsContext3DCommandBufferImpl* context =
+        static_cast<WebGraphicsContext3DCommandBufferImpl*>(
+            web_view->sharedGraphicsContext3D());
+    DCHECK(context);
+    BrowserPluginHostMsg_Surface_Params params;
+    params.gpu_process_id = context->GetGPUProcessID();
+    params.client_id = context->GetChannelID();
+    params.context_id = context->GetContextID();
+    params.texture_id[0] = context->createTexture();
+    params.texture_id[1] = context->createTexture();
+    params.sync_point = context->insertSyncPoint();
     BrowserPluginManager::Get()->Send(
         new BrowserPluginHostMsg_NavigateOrCreateGuest(
             render_view_->GetRoutingID(),
             instance_id_,
             parent_frame_,
-            src));
+            src,
+            params));
   }
   src_ = src;
   guest_crashed_ = false;
 }
 
 bool BrowserPlugin::ParseSrcAttribute(
     const WebKit::WebPluginParams& params,
     std::string* src) {
   // Get the src attribute from the attributes vector
   for (unsigned i = 0; i < params.attributeNames.size(); ++i) {
@@ skipping 23 matching lines @@
     for (; it != listeners.end(); ++it) {
       it->Dispose();
     }
   }
   event_listener_map_.clear();
 }
 
 void BrowserPlugin::UpdateRect(
     int message_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
-  if (width() != params.view_size.width() ||
-      height() != params.view_size.height()) {
+  if ((width() != params.view_size.width() ||
+       height() != params.view_size.height()) && params.needs_ack) {
     BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
         render_view_->GetRoutingID(),
         instance_id_,
         message_id,
         gfx::Size(width(), height())));
     return;
   }
 
   float backing_store_scale_factor =
       backing_store_.get() ? backing_store_->GetScaleFactor() : 1.0f;
@@ skipping 13 matching lines @@
                                        params.scroll_rect,
                                        params.view_size);
   }
   for (unsigned i = 0; i < params.copy_rects.size(); i++) {
     backing_store_->PaintToBackingStore(params.bitmap_rect,
                                         params.copy_rects,
                                         damage_buffer_);
   }
   // Invalidate the container.
   container_->invalidate();
-  BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
-      render_view_->GetRoutingID(),
-      instance_id_,
-      message_id,
-      gfx::Size()));
+  if (params.needs_ack)
+    BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
+        render_view_->GetRoutingID(),
+        instance_id_,
+        message_id,
+        gfx::Size()));
 }
 
 void BrowserPlugin::GuestCrashed() {
   guest_crashed_ = true;
   container_->invalidate();
 
   if (!HasListeners(kCrashEventName))
     return;
 
   EventListeners& listeners = event_listener_map_[kCrashEventName];
@@ skipping 32 matching lines @@
 void BrowserPlugin::AdvanceFocus(bool reverse) {
   // We do not have a RenderView when we are testing.
   if (render_view_)
     render_view_->GetWebView()->advanceFocus(reverse);
 }
 
 bool BrowserPlugin::HasListeners(const std::string& event_name) {
   return event_listener_map_.find(event_name) != event_listener_map_.end();
 }
 
+void BrowserPlugin::SurfaceResize(const gfx::Size& size) {
+  if (!provider_) {
+    provider_ = new BrowserPluginTextureProvider(instance_id_, render_view_);
+    provider_->Resize(gfx::Size(width(), height()));
+  }
+
+  provider_->SurfaceResize(size);
+}
+
+void BrowserPlugin::BuffersSwapped(
+    uint64 surface_handle,
+    const BrowserPlugin_SwapInfo& info) {
+  DCHECK(!ignore_input_);
+  DCHECK(surface_handle);
+  DCHECK(container_);
+  DCHECK(provider_);
+
+  provider_->SetDelayedSwap(surface_handle, info);
+
+  container_->setBackingTextureProvider(provider_);
+  container_->commitBackingTexture();
+
+  ignore_input_ = true;

[scshunt, 2012/08/12 01:42:45]

ignore_input should probably be commented, explaining the deadlock.

+}
+
+void BrowserPlugin::TextureProviderIsReady() {
+  ignore_input_ = false;
+}
+
 bool BrowserPlugin::AddEventListener(const std::string& event_name,
                                      v8::Local<v8::Function> function) {
   EventListeners& listeners = event_listener_map_[event_name];
   for (unsigned int i = 0; i < listeners.size(); ++i) {
     if (listeners[i] == function)
       return false;
   }
   v8::Persistent<v8::Function> persistent_function =
       v8::Persistent<v8::Function>::New(function);
   listeners.push_back(persistent_function);
@@ skipping 107 matching lines @@
       render_view_->GetRoutingID(),
       instance_id_,
       params));
   resize_pending_ = true;
 
   if (damage_buffer_) {
     RenderProcess::current()->FreeTransportDIB(damage_buffer_);
     damage_buffer_ = NULL;
   }
   damage_buffer_ = new_damage_buffer;
+
+  if (provider_)
+    provider_->Resize(gfx::Size(window_rect.width, window_rect.height));
 }
 
 void BrowserPlugin::updateFocus(bool focused) {
   BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_SetFocus(
       render_view_->GetRoutingID(),
       instance_id_,
       focused));
 }
 
 void BrowserPlugin::updateVisibility(bool visible) {
 }
 
 bool BrowserPlugin::acceptsInputEvents() {
   return true;
 }
 
 bool BrowserPlugin::handleInputEvent(const WebKit::WebInputEvent& event,
                                      WebKit::WebCursorInfo& cursor_info) {
-  if (guest_crashed_ || src_.empty())
+  if (guest_crashed_ || src_.empty() || !container_ || ignore_input_)
     return false;
   bool handled = false;
   WebCursor cursor;
   IPC::Message* message =
       new BrowserPluginHostMsg_HandleInputEvent(
           render_view_->GetRoutingID(),
           &handled,
           &cursor);
   message->WriteInt(instance_id_);
   message->WriteData(reinterpret_cast<const char*>(&plugin_rect_),
@@ skipping 21 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content