Browser Plugin: Remove dependency on NPAPI

content/renderer/browser_plugin/browser_plugin.cc

 // Copyright 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/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/browser_plugin/browser_plugin_constants.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/browser_plugin_delegate.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/child_frame_compositing_helper.h"
 #include "content/renderer/cursor_utils.h"
 #include "content/renderer/drop_data_builder.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/sad_plugin.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
-#include "third_party/WebKit/public/web/WebBindings.h"
-#include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using blink::WebCanvas;
 using blink::WebPluginContainer;
@@ skipping 27 matching lines @@
                              blink::WebFrame* frame,
                              scoped_ptr<BrowserPluginDelegate> delegate)
     : attached_(false),
       attach_pending_(false),
       render_view_(render_view->AsWeakPtr()),
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       last_device_scale_factor_(GetDeviceScaleFactor()),
       sad_guest_(NULL),
       guest_crashed_(false),
-      content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       mouse_locked_(false),
       browser_plugin_manager_(render_view->GetBrowserPluginManager()),
       browser_plugin_instance_id_(browser_plugin::kInstanceIDNone),
+      contents_opaque_(true),
       delegate_(delegate.Pass()),
       weak_ptr_factory_(this) {
   browser_plugin_instance_id_ = browser_plugin_manager()->GetNextInstanceID();
 
   if (delegate_)
     delegate_->SetElementInstanceID(browser_plugin_instance_id_);
 }
 
 BrowserPlugin::~BrowserPlugin() {
   browser_plugin_manager()->RemoveBrowserPlugin(browser_plugin_instance_id_);
 
   if (!ready())
     return;
 
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_PluginDestroyed(render_view_routing_id_,
                                                browser_plugin_instance_id_));
 }
 
 bool BrowserPlugin::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPlugin, message)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_Attach_ACK, OnAttachACK)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_AdvanceFocus, OnAdvanceFocus)
     IPC_MESSAGE_HANDLER_GENERIC(BrowserPluginMsg_CompositorFrameSwapped,
                                 OnCompositorFrameSwapped(message))
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_CopyFromCompositingSurface,
                         OnCopyFromCompositingSurface)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestGone, OnGuestGone)
+    IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetContentsOpaque, OnSetContentsOpaque)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetCursor, OnSetCursor)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetMouseLock, OnSetMouseLock)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_ShouldAcceptTouchEvents,
                         OnShouldAcceptTouchEvents)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BrowserPlugin::UpdateDOMAttribute(const std::string& attribute_name,
                                        const std::string& attribute_value) {
   if (!container())
     return;
 
   blink::WebElement element = container()->element();
   blink::WebString web_attribute_name =
       blink::WebString::fromUTF8(attribute_name);
-  if (!HasDOMAttribute(attribute_name) ||
-      (std::string(element.getAttribute(web_attribute_name).utf8()) !=
-          attribute_value)) {
-    element.setAttribute(web_attribute_name,
-        blink::WebString::fromUTF8(attribute_value));
-  }
-}
-
-void BrowserPlugin::RemoveDOMAttribute(const std::string& attribute_name) {
-  if (!container())
-    return;
-
-  container()->element().removeAttribute(
-      blink::WebString::fromUTF8(attribute_name));
-}
-
-std::string BrowserPlugin::GetDOMAttributeValue(
-    const std::string& attribute_name) const {
-  if (!container())
-    return std::string();
-
-  return container()->element().getAttribute(
-      blink::WebString::fromUTF8(attribute_name)).utf8();
-}
-
-bool BrowserPlugin::HasDOMAttribute(const std::string& attribute_name) const {
-  if (!container())
-    return false;
-
-  return container()->element().hasAttribute(
-      blink::WebString::fromUTF8(attribute_name));
-}
-
-bool BrowserPlugin::GetAllowTransparencyAttribute() const {
-  return HasDOMAttribute(browser_plugin::kAttributeAllowTransparency);
-}
-
-void BrowserPlugin::ParseAllowTransparencyAttribute() {
-  if (!ready())
-    return;
-
-  bool opaque = !GetAllowTransparencyAttribute();
-
-  if (compositing_helper_.get())
-    compositing_helper_->SetContentsOpaque(opaque);
-
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetContentsOpaque(
-        render_view_routing_id_,
-        browser_plugin_instance_id_,
-        opaque));
+  element.setAttribute(web_attribute_name,
+      blink::WebString::fromUTF8(attribute_value));
 }
 
 void BrowserPlugin::Attach() {
   if (ready()) {
     attached_ = false;
     guest_crashed_ = false;
     EnableCompositing(false);
     if (compositing_helper_.get()) {
       compositing_helper_->OnContainerDestroy();
       compositing_helper_ = NULL;
     }
   }
 
   // TODO(fsamuel): Add support for reattachment.
   BrowserPluginHostMsg_Attach_Params attach_params;
   attach_params.focused = ShouldGuestBeFocused();
   attach_params.visible = visible_;
-  attach_params.opaque = !GetAllowTransparencyAttribute();
   attach_params.origin = plugin_rect().origin();
   gfx::Size view_size(width(), height());
   if (!view_size.IsEmpty()) {
     PopulateResizeGuestParameters(view_size,
                                   &attach_params.resize_guest_params);
   }
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_Attach(
       render_view_routing_id_,
       browser_plugin_instance_id_,
       attach_params));
@@ skipping 65 matching lines @@
   // Queue up showing the sad graphic to give content embedders an opportunity
   // to fire their listeners and potentially overlay the webview with custom
   // behavior. If the BrowserPlugin is destroyed in the meantime, then the
   // task will not be executed.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&BrowserPlugin::ShowSadGraphic,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void BrowserPlugin::OnSetContentsOpaque(int browser_plugin_instance_id,
+                                        bool opaque) {
+  if (contents_opaque_ == opaque)
+    return;
+  contents_opaque_ = opaque;
+  if (compositing_helper_.get())
+    compositing_helper_->SetContentsOpaque(opaque);
+}
+
 void BrowserPlugin::OnSetCursor(int browser_plugin_instance_id,
                                 const WebCursor& cursor) {
   cursor_ = cursor;
 }
 
 void BrowserPlugin::OnSetMouseLock(int browser_plugin_instance_id,
                                    bool enable) {
   if (enable) {
     if (mouse_locked_)
       return;
@@ skipping 59 matching lines @@
 }
 
 WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   if (!container)
     return false;
 
-  // Tell |container| to allow this plugin to use script objects.
-  npp_.reset(new NPP_t);
-  container->allowScriptObjects();
-
-  bindings_.reset(new BrowserPluginBindings(this));
   container_ = container;
   container_->setWantsWheelEvents(true);
 
   g_plugin_container_map.Get().insert(std::make_pair(container_, this));
 
   // This is a way to notify observers of our attributes that this plugin is
   // available in render tree.
   // TODO(lazyboy): This should be done through the delegate instead. Perhaps
   // by firing an event from there.
   UpdateDOMAttribute("internalinstanceid",
                      base::IntToString(browser_plugin_instance_id_));
 
   browser_plugin_manager()->AddBrowserPlugin(browser_plugin_instance_id_, this);
   return true;
 }
 
 void BrowserPlugin::EnableCompositing(bool enable) {
   bool enabled = !!compositing_helper_.get();
   if (enabled == enable)
     return;
 
   if (enable) {
     DCHECK(!compositing_helper_.get());
     if (!compositing_helper_.get()) {
       compositing_helper_ = ChildFrameCompositingHelper::CreateForBrowserPlugin(
           weak_ptr_factory_.GetWeakPtr());
     }
   }
   compositing_helper_->EnableCompositing(enable);
-  compositing_helper_->SetContentsOpaque(!GetAllowTransparencyAttribute());
+  compositing_helper_->SetContentsOpaque(contents_opaque_);
 
   if (!enable) {
     DCHECK(compositing_helper_.get());
     compositing_helper_->OnContainerDestroy();
     compositing_helper_ = NULL;
   }
 }
 
 void BrowserPlugin::destroy() {
-  // If the plugin was initialized then it has a valid |npp_| identifier, and
-  // the |container_| must clear references to the plugin's script objects.
-  DCHECK(!npp_ || container_);
   if (container_) {
-    container_->clearScriptObjects();
+    //container_->clearScriptObjects();
 
     // The BrowserPlugin's WebPluginContainer is deleted immediately after this
     // call returns, so let's not keep a reference to it around.
     g_plugin_container_map.Get().erase(container_);
   }
 
   if (compositing_helper_.get())
     compositing_helper_->OnContainerDestroy();
   container_ = NULL;
   // Will be a no-op if the mouse is not currently locked.
   if (render_view_)
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(this);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-NPObject* BrowserPlugin::scriptableObject() {
-  if (!bindings_)
-    return NULL;
-
-  NPObject* browser_plugin_np_object(bindings_->np_object());
-  // The object is expected to be retained before it is returned.
-  blink::WebBindings::retainObject(browser_plugin_np_object);
-  return browser_plugin_np_object;
-}
-
-NPP BrowserPlugin::pluginNPP() {
-  return npp_.get();
-}
-
 bool BrowserPlugin::supportsKeyboardFocus() const {
   return true;
 }
 
 bool BrowserPlugin::supportsEditCommands() const {
   return true;
 }
 
 bool BrowserPlugin::supportsInputMethod() const {
   return true;
@@ skipping 33 matching lines @@
 
 // static
 bool BrowserPlugin::ShouldForwardToBrowserPlugin(
     const IPC::Message& message) {
   switch (message.type()) {
     case BrowserPluginMsg_Attach_ACK::ID:
     case BrowserPluginMsg_AdvanceFocus::ID:
     case BrowserPluginMsg_CompositorFrameSwapped::ID:
     case BrowserPluginMsg_CopyFromCompositingSurface::ID:
     case BrowserPluginMsg_GuestGone::ID:
+    case BrowserPluginMsg_SetContentsOpaque::ID:
     case BrowserPluginMsg_SetCursor::ID:
     case BrowserPluginMsg_SetMouseLock::ID:
     case BrowserPluginMsg_ShouldAcceptTouchEvents::ID:
       return true;
     default:
       break;
   }
   return false;
 }
 
@@ skipping 216 matching lines @@
     const blink::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 browser_plugin_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content