Texture provider to feed data to the impl side thread for webview compositing.

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"
 #if defined (OS_WIN)
 #include "base/sys_info.h"
 #endif
 #include "base/utf_string_conversions.h"
 #include "content/common/browser_plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
+#include "content/renderer/gpu/compositor_thread.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/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"
@@ skipping 60 matching lines @@
       sad_guest_(NULL),
       guest_crashed_(false),
       resize_pending_(false),
       navigate_src_sent_(false),
       process_id_(-1),
       persist_storage_(false),
       content_window_routing_id_(MSG_ROUTING_NONE),
       focused_(false),
       visible_(true),
       current_nav_entry_index_(0),
-      nav_entry_count_(0) {
+      nav_entry_count_(0),
+      provider_(0),
+      compositingPossible_(false),
+      compositingEnabled_(false) {
   BrowserPluginManager::Get()->AddBrowserPlugin(instance_id, this);
   bindings_.reset(new BrowserPluginBindings(this));
 
   InitializeEvents();
 
   ParseAttributes(params);
 }
 
 BrowserPlugin::~BrowserPlugin() {
   if (damage_buffer_)
     FreeDamageBuffer();
   RemoveEventListeners();
   BrowserPluginManager::Get()->RemoveBrowserPlugin(instance_id_);
   BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(
           render_view_routing_id_,
           instance_id_));
+
+  if (provider_)
+    provider_->Destroy();
 }
 
 void BrowserPlugin::Cleanup() {
   if (damage_buffer_)
     FreeDamageBuffer();
 }
 
 std::string BrowserPlugin::GetSrcAttribute() const {
   return src_;
 }
@@ skipping 13 matching lines @@
             storage_partition_id_,
             persist_storage_,
             focused_,
             visible_));
   }
 
   scoped_ptr<BrowserPluginHostMsg_ResizeGuest_Params> params(
       GetPendingResizeParams());
   DCHECK(!params->resize_pending);
 
+  WebKit::WebView* web_view = render_view_->webview();
+  DCHECK(web_view);
+  WebGraphicsContext3DCommandBufferImpl* context = NULL;
+  if (compositingPossible_) {
+    context = static_cast<WebGraphicsContext3DCommandBufferImpl*>(
+        web_view->sharedGraphicsContext3D());
+  }
+  ProvideHWCompositingInfo(params.get(), context);
+
   BrowserPluginManager::Get()->Send(
       new BrowserPluginHostMsg_NavigateGuest(
           render_view_routing_id_,
           instance_id_,
           src,
           *params));
   // Record that we sent a NavigateGuest message to embedder.
   // Once this instance has navigated, the storage partition cannot be changed,
   // so this value is used for enforcing this.
   navigate_src_sent_ = true;
@@ skipping 88 matching lines @@
 
 void BrowserPlugin::InitializeEvents() {
   event_listener_map_[kExitEventName] = EventListeners();
   event_listener_map_[kLoadAbortEventName] = EventListeners();
   event_listener_map_[kLoadCommitEventName] = EventListeners();
   event_listener_map_[kLoadRedirectEventName] = EventListeners();
   event_listener_map_[kLoadStartEventName] = EventListeners();
   event_listener_map_[kLoadStopEventName] = EventListeners();
 }
 
+void BrowserPlugin::InitializeTextureProvider() {
+  RenderThreadImpl* render_thread_impl = RenderThreadImpl::current();
+  CompositorThread* compositor_thread = render_thread_impl->compositor_thread();
+  compositingPossible_ = !!compositor_thread;
+
+  if (compositingPossible_) {
+    MessageLoop* compositor_thread_loop = compositor_thread->message_loop();
+    provider_ = new BrowserPluginTextureProvider(
+      instance_id_,
+      render_view_->GetRoutingID(),
+      RenderThreadImpl::Get()->GetChannel(),
+      compositor_thread_loop->message_loop_proxy());
+    provider_->Initialize();
+  }
+}
+
+void BrowserPlugin::ProvideHWCompositingInfo(
+    BrowserPluginHostMsg_ResizeGuest_Params* params,
+    WebGraphicsContext3DCommandBufferImpl* context) {
+  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->gpu_process_id = 0;
+    params->client_id = 0;
+    params->context_id = 0;
+    params->texture_id_0 = 0;
+    params->texture_id_1 = 0;
+    params->sync_point = 0;
+  }
+}
+
 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();
@@ skipping 126 matching lines @@
   for (unsigned i = 0; i < params.copy_rects.size(); i++) {
     backing_store_->PaintToBackingStore(params.bitmap_rect,
                                         params.copy_rects,
                                         damage_buffer_);
   }
   // Invalidate the container.
   // If the BrowserPlugin is scheduled to be deleted, then container_ will be
   // NULL so we shouldn't attempt to access it.
   if (container_)
     container_->invalidate();
+
   BrowserPluginManager::Get()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
       render_view_routing_id_,
       instance_id_,
       message_id,
       gfx::Size()));
 }
 
 void BrowserPlugin::GuestGone(int process_id, base::TerminationStatus status) {
   // We fire the event listeners before painting the sad graphic to give the
   // developer an opportunity to display an alternative overlay image on crash.
@@ skipping 200 matching lines @@
 
 WebKit::WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   container_ = container;
   return true;
 }
 
+void BrowserPlugin::EnableCompositing() {
+  if (!compositingPossible_) {
+    LOG(WARNING) << "BrowserPlugin compositing requires an impl thread, "
+                 << "try running with --enable-threaded-compositing";
+    return;
+  }
+  if (!compositingEnabled_)
+    container_->setBackingTextureProvider(provider_);
+
+  compositingEnabled_ = true;
+}
+
 void BrowserPlugin::destroy() {
   // The BrowserPlugin's WebPluginContainer is deleted immediately after this
   // call returns, so let's not keep a reference to it around.
   container_ = NULL;
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 NPObject* BrowserPlugin::scriptableObject() {
   NPObject* browser_plugin_np_object(bindings_->np_object());
   // The object is expected to be retained before it is returned.
@@ skipping 44 matching lines @@
   float inverse_scale_factor =  1.0f / backing_store_->GetScaleFactor();
   canvas->scale(inverse_scale_factor, inverse_scale_factor);
   canvas->drawBitmap(backing_store_->GetBitmap(), 0, 0);
 }
 
 void BrowserPlugin::updateGeometry(
     const WebRect& window_rect,
     const WebRect& clip_rect,
     const WebVector<WebRect>& cut_outs_rects,
     bool is_visible) {
+
   int old_width = width();
   int old_height = height();
   plugin_rect_ = window_rect;
   if (old_width == window_rect.width &&
       old_height == window_rect.height) {
     return;
   }
 
   const size_t stride = skia::PlatformCanvas::StrideForWidth(window_rect.width);
   // Make sure the size of the damage buffer is at least four bytes so that we
@@ skipping 66 matching lines @@
   } else {
     BrowserPluginHostMsg_ResizeGuest_Params* params =
         new BrowserPluginHostMsg_ResizeGuest_Params;
 
     // We don't have a pending resize to send, so we send an invalid transport
     // dib Id.
     params->damage_buffer_id = TransportDIB::Id();
     params->width = width();
     params->height = height();
     params->resize_pending = false;
+    // Reset HW compositing info.
+    ProvideHWCompositingInfo(params, NULL);
     return params;
   }
 }
 
 TransportDIB* BrowserPlugin::CreateTransportDIB(const size_t size) {
 #if defined(OS_MACOSX)
   TransportDIB::Handle handle;
   // On OSX we don't let the browser manage the transport dib. We manage the
   // deletion of the dib in FreeDamageBuffer().
   IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(
@@ skipping 106 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content