Move the plugin placeholder from CppBoundClass to gin::Wrappable

components/plugins/renderer/plugin_placeholder.cc

 // Copyright 2013 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 "components/plugins/renderer/plugin_placeholder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/string_escape.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
+#include "gin/object_template_builder.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/re2/re2/re2.h"
 
 using content::RenderThread;
 using content::UserMetricsAction;
 using blink::WebElement;
 using blink::WebFrame;
 using blink::WebMouseEvent;
 using blink::WebNode;
 using blink::WebPlugin;
 using blink::WebPluginContainer;
 using blink::WebPluginParams;
 using blink::WebScriptSource;
 using blink::WebURLRequest;
-using webkit_glue::CppArgumentList;
-using webkit_glue::CppVariant;
 
 namespace plugins {
 
+gin::WrapperInfo PluginPlaceholder::kWrapperInfo = {gin::kEmbedderNativeGin};
+
 PluginPlaceholder::PluginPlaceholder(content::RenderFrame* render_frame,
                                      WebFrame* frame,
                                      const WebPluginParams& params,
                                      const std::string& html_data,
                                      GURL placeholderDataUrl)
     : content::RenderFrameObserver(render_frame),
       frame_(frame),
       plugin_params_(params),
       plugin_(WebViewPlugin::Create(this,
                                     render_frame->GetWebkitPreferences(),
                                     html_data,
                                     placeholderDataUrl)),
       is_blocked_for_prerendering_(false),
       allow_loading_(false),
       hidden_(false),
       finished_loading_(false) {}
 
 PluginPlaceholder::~PluginPlaceholder() {}
 
-void PluginPlaceholder::BindWebFrame(WebFrame* frame) {
-  BindToJavascript(frame, "plugin");
-  BindCallback(
-      "load",
-      base::Bind(&PluginPlaceholder::LoadCallback, base::Unretained(this)));
-  BindCallback(
-      "hide",
-      base::Bind(&PluginPlaceholder::HideCallback, base::Unretained(this)));
-  BindCallback("didFinishLoading",
-               base::Bind(&PluginPlaceholder::DidFinishLoadingCallback,
-                          base::Unretained(this)));
+gin::ObjectTemplateBuilder PluginPlaceholder::GetObjectTemplateBuilder(
+    v8::Isolate* isolate) {
+  return gin::Wrappable<PluginPlaceholder>::GetObjectTemplateBuilder(isolate)
+      .SetMethod("load", &PluginPlaceholder::LoadCallback)
+      .SetMethod("hide", &PluginPlaceholder::HideCallback)
+      .SetMethod("didFinishLoading",
+                 &PluginPlaceholder::DidFinishLoadingCallback);
 }
 
 void PluginPlaceholder::ReplacePlugin(WebPlugin* new_plugin) {
   CHECK(plugin_);
   if (!new_plugin) return;
   WebPluginContainer* container = plugin_->container();
   // Set the new plug-in on the container before initializing it.
   container->setPlugin(new_plugin);
   // Save the element in case the plug-in is removed from the page during
   // initialization.
   WebElement element = container->element();
   if (!new_plugin->initialize(container)) {
     // We couldn't initialize the new plug-in. Restore the old one and abort.
     container->setPlugin(plugin_);
     return;
   }
 
-  // The plug-in has been removed from the page. Destroy the old plug-in
-  // (which will destroy us).
+  // The plug-in has been removed from the page. Destroy the old plug-in. We
+  // will be destroyed as soon as V8 garbage collects us.
   if (!element.pluginContainer()) {
     plugin_->destroy();
+    plugin_ = NULL;
     return;
   }
 
   // During initialization, the new plug-in might have replaced itself in turn
   // with another plug-in. Make sure not to use the passed in |new_plugin| after
   // this point.
   new_plugin = container->plugin();
 
   plugin_->RestoreTitleText();
   container->invalidate();
   container->reportGeometry();
   plugin_->ReplayReceivedData(new_plugin);
   plugin_->destroy();
+  plugin_ = NULL;
 }
 
 void PluginPlaceholder::HidePlugin() {
   hidden_ = true;
   WebPluginContainer* container = plugin_->container();
   WebElement element = container->element();
   element.setAttribute("style", "display: none;");
   // If we have a width and height, search for a parent (often <div>) with the
   // same dimensions. If we find such a parent, hide that as well.
   // This makes much more uncovered page content usable (including clickable)
@@ skipping 28 matching lines @@
       if (element.hasAttribute("style")) {
         std::string style_str = element.getAttribute("style").utf8();
         if (RE2::PartialMatch(style_str, width_str) &&
             RE2::PartialMatch(style_str, height_str))
           element.setAttribute("style", "display: none;");
       }
     }
   }
 }
 
-void PluginPlaceholder::WillDestroyPlugin() { delete this; }
-
 void PluginPlaceholder::SetMessage(const base::string16& message) {
   message_ = message;
   if (finished_loading_)
     UpdateMessage();
 }
 
 void PluginPlaceholder::UpdateMessage() {
   std::string script =
       "window.setMessage(" + base::GetQuotedJSONString(message_) + ")";
   plugin_->web_view()->mainFrame()->executeScript(
       WebScriptSource(base::ASCIIToUTF16(script)));
 }
 
 void PluginPlaceholder::ShowContextMenu(const WebMouseEvent& event) {
   // Does nothing by default. Will be overridden if a specific browser wants
   // a context menu.
   return;
 }
 
+void PluginPlaceholder::OnDestruct() {
+  frame_ = NULL;
+}
+
 void PluginPlaceholder::OnLoadBlockedPlugins(const std::string& identifier) {
   if (!identifier.empty() && identifier != identifier_)
     return;
 
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Load_UI"));
   LoadPlugin();
 }
 
 void PluginPlaceholder::OnSetIsPrerendering(bool is_prerendering) {
   // Prerendering can only be enabled prior to a RenderView's first navigation,
@@ skipping 14 matching lines @@
   }
 
   // TODO(mmenke):  In the case of prerendering, feed into
   //                ChromeContentRendererClient::CreatePlugin instead, to
   //                reduce the chance of future regressions.
   WebPlugin* plugin =
       render_frame()->CreatePlugin(frame_, plugin_info_, plugin_params_);
   ReplacePlugin(plugin);
 }
 
-void PluginPlaceholder::LoadCallback(const CppArgumentList& args,
-                                     CppVariant* result) {
+void PluginPlaceholder::LoadCallback() {
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Load_Click"));
   LoadPlugin();
 }
 
-void PluginPlaceholder::HideCallback(const CppArgumentList& args,
-                                     CppVariant* result) {
+void PluginPlaceholder::HideCallback() {
   RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Hide_Click"));
   HidePlugin();
 }
 
-void PluginPlaceholder::DidFinishLoadingCallback(const CppArgumentList& args,
-                                                 CppVariant* result) {
+void PluginPlaceholder::DidFinishLoadingCallback() {
   finished_loading_ = true;
   if (message_.length() > 0)
     UpdateMessage();
 }
 
 void PluginPlaceholder::SetPluginInfo(
     const content::WebPluginInfo& plugin_info) {
   plugin_info_ = plugin_info;
 }
 
 const content::WebPluginInfo& PluginPlaceholder::GetPluginInfo() const {
   return plugin_info_;
 }
 
 void PluginPlaceholder::SetIdentifier(const std::string& identifier) {
   identifier_ = identifier;
 }
 
 blink::WebFrame* PluginPlaceholder::GetFrame() { return frame_; }
 
 const blink::WebPluginParams& PluginPlaceholder::GetPluginParams() const {
   return plugin_params_;
 }
 
 }  // namespace plugins