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());
+    BrowserPluginHostMsg_Surface_Params params;
+    if (context) {
+      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();
+    } else {
+      // Zero textures signal a lack of compositing
+      params.texture_id[0] = params.texture_id[1] = 0;
+    }
     BrowserPluginManager::Get()->Send(
         new BrowserPluginHostMsg_NavigateGuest(
             render_view_->GetRoutingID(),
             instance_id_,
             parent_frame_,
             src,
-            gfx::Size(width(), height())));
+            gfx::Size(width(), height()),
+            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) {
     std::string attributeName = params.attributeNames[i].utf8();
     if (LowerCaseEqualsASCII(attributeName, kSrcAttribute)) {
       *src = params.attributeValues[i].utf8();
       return true;
     }
   }
   return false;
 }
 
 float BrowserPlugin::GetDeviceScaleFactor() const {
   if (!render_view_)
     return 1.0f;
   return render_view_->GetWebView()->deviceScaleFactor();
 }
 
+BrowserPluginTextureProvider* BrowserPlugin::CreateTextureProvider(
+    int instance_id,
+    int routing_id) const {
+  return new BrowserPluginTextureProvider(
+      instance_id_,
+      render_view_->GetRoutingID(),
+      RenderThreadImpl::Get()->GetChannel());
+}
+
 void BrowserPlugin::RemoveEventListeners() {
   EventListenerMap::iterator event_listener_map_iter =
       event_listener_map_.begin();
   for (; event_listener_map_iter != event_listener_map_.end();
        ++event_listener_map_iter) {
     EventListeners& listeners =
         event_listener_map_[event_listener_map_iter->first];
     EventListeners::iterator it = listeners.begin();
     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()) {
-    BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
-        render_view_->GetRoutingID(),
-        instance_id_,
-        message_id,
-        gfx::Size(width(), height())));
+    if (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;
 
   if (params.is_resize_ack ||
       backing_store_scale_factor != params.scale_factor) {
     resize_pending_ = !params.is_resize_ack;
     backing_store_.reset(
         new BrowserPluginBackingStore(gfx::Size(width(), height()),
                                       params.scale_factor));
   }
 
   // Update the backing store.
   if (!params.scroll_rect.IsEmpty()) {
     backing_store_->ScrollBackingStore(params.dx,
                                        params.dy,
                                        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_ = CreateTextureProvider(instance_id_,
+                                      render_view_->GetRoutingID());
+    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;
+}
+
+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 106 matching lines @@
   BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_ResizeGuest(
       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())
+  // In certain circumstances we won't pass input on to the guest. If we are
+  // deliberately ignoring input to a working guest, we should sink the input
+  // event so that we won't have a random stray input event handled by the
+  // surrounding page.
+  if (guest_crashed_ || src_.empty() || !container_)
     return false;
+  if (ignore_input_)
+    return true;
+
   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_),
                      sizeof(gfx::Rect));
@@ skipping 20 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content