Reland: Plugin Placeholders: Refactor for platforms that don't support plugins

chrome/renderer/plugins/chrome_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 "chrome/renderer/plugins/chrome_plugin_placeholder.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/prerender_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/renderer_resources.h"
 #include "chrome/renderer/chrome_content_renderer_client.h"
 #include "chrome/renderer/custom_menu_commands.h"
 #include "chrome/renderer/plugins/plugin_preroller.h"
 #include "chrome/renderer/plugins/plugin_uma.h"
 #include "components/content_settings/content/common/content_settings_messages.h"
-#include "content/app/strings/grit/content_strings.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/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/jstemplate_builder.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/url_util.h"
 
 using base::UserMetricsAction;
 using blink::WebDocument;
 using blink::WebElement;
 using blink::WebFrame;
 using blink::WebLocalFrame;
 using blink::WebMouseEvent;
 using blink::WebNode;
 using blink::WebPlugin;
 using blink::WebPluginContainer;
 using blink::WebPluginParams;
 using content::RenderThread;
 using content::RenderView;
 
 namespace {
-const plugins::PluginPlaceholder* g_last_active_menu = NULL;
+const ChromePluginPlaceholder* g_last_active_menu = NULL;
 }  // namespace
 
-// The placeholder is loaded in normal web renderer processes, so it should not
-// have a chrome:// scheme that might let it be confused with a WebUI page.
-const char ChromePluginPlaceholder::kPluginPlaceholderDataURL[] =
-    "data:text/html,pluginplaceholderdata";
+gin::WrapperInfo ChromePluginPlaceholder::kWrapperInfo = {
+    gin::kEmbedderNativeGin};
 
 ChromePluginPlaceholder::ChromePluginPlaceholder(
     content::RenderFrame* render_frame,
     blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params,
     const std::string& html_data,
     const base::string16& title)
     : plugins::LoadablePluginPlaceholder(render_frame,
                                          frame,
                                          params,
-                                         html_data,
-                                         GURL(kPluginPlaceholderDataURL)),
+                                         html_data),
       status_(ChromeViewHostMsg_GetPluginInfo_Status::kAllowed),
       title_(title),
 #if defined(ENABLE_PLUGIN_INSTALLATION)
       placeholder_routing_id_(MSG_ROUTING_NONE),
 #endif
       has_host_(false),
       context_menu_request_id_(0) {
   RenderThread::Get()->AddObserver(this);
 }
 
 ChromePluginPlaceholder::~ChromePluginPlaceholder() {
   RenderThread::Get()->RemoveObserver(this);
   if (context_menu_request_id_ && render_frame())
     render_frame()->CancelContextMenu(context_menu_request_id_);
 
 #if defined(ENABLE_PLUGIN_INSTALLATION)
   if (placeholder_routing_id_ == MSG_ROUTING_NONE)
     return;
   RenderThread::Get()->RemoveRoute(placeholder_routing_id_);
   if (has_host_) {
     RenderThread::Get()->Send(new ChromeViewHostMsg_RemovePluginPlaceholderHost(
         routing_id(), placeholder_routing_id_));
   }
 #endif
 }
 
 // static
-ChromePluginPlaceholder* ChromePluginPlaceholder::CreateMissingPlugin(
+ChromePluginPlaceholder* ChromePluginPlaceholder::CreateLoadableMissingPlugin(
     content::RenderFrame* render_frame,
     WebLocalFrame* frame,
     const WebPluginParams& params) {
   const base::StringPiece template_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_BLOCKED_PLUGIN_HTML));
 
   base::DictionaryValue values;
   values.SetString("message",
                    l10n_util::GetStringUTF8(IDS_PLUGIN_NOT_SUPPORTED));
 
   std::string html_data = webui::GetI18nTemplateHtml(template_html, &values);
 
-  // |missing_plugin| will destroy itself when its WebViewPlugin is going away.
-  ChromePluginPlaceholder* missing_plugin = new ChromePluginPlaceholder(
-      render_frame, frame, params, html_data, params.mimeType);
-  missing_plugin->set_allow_loading(true);
-  return missing_plugin;
+  // Will destroy itself when its WebViewPlugin is going away.
+  return new ChromePluginPlaceholder(render_frame, frame, params, html_data,
+                                     params.mimeType);
 }
 
 // static
-ChromePluginPlaceholder* ChromePluginPlaceholder::CreateErrorPlugin(
-    content::RenderFrame* render_frame,
-    const base::FilePath& file_path) {
-  base::DictionaryValue values;
-  values.SetString("message",
-                   l10n_util::GetStringUTF8(IDS_PLUGIN_INITIALIZATION_ERROR));
-
-  const base::StringPiece template_html(
-      ResourceBundle::GetSharedInstance().GetRawDataResource(
-          IDR_BLOCKED_PLUGIN_HTML));
-  std::string html_data = webui::GetI18nTemplateHtml(template_html, &values);
-
-  WebPluginParams params;
-  // |missing_plugin| will destroy itself when its WebViewPlugin is going away.
-  ChromePluginPlaceholder* plugin = new ChromePluginPlaceholder(
-      render_frame, NULL, params, html_data, params.mimeType);
-
-  RenderThread::Get()->Send(new ChromeViewHostMsg_CouldNotLoadPlugin(
-      plugin->routing_id(), file_path));
-  return plugin;
-}
-
-// static
 ChromePluginPlaceholder* ChromePluginPlaceholder::CreateBlockedPlugin(
     content::RenderFrame* render_frame,
     WebLocalFrame* frame,
     const WebPluginParams& params,
     const content::WebPluginInfo& info,
     const std::string& identifier,
     const base::string16& name,
     int template_id,
     const base::string16& message,
     const PlaceholderPosterInfo& poster_info) {
@@ skipping 20 matching lines @@
       ResourceBundle::GetSharedInstance().GetRawDataResource(template_id));
 
   DCHECK(!template_html.empty()) << "unable to load template. ID: "
                                  << template_id;
   std::string html_data = webui::GetI18nTemplateHtml(template_html, &values);
 
   // |blocked_plugin| will destroy itself when its WebViewPlugin is going away.
   ChromePluginPlaceholder* blocked_plugin = new ChromePluginPlaceholder(
       render_frame, frame, params, html_data, name);
 
-#if defined(ENABLE_PLUGINS)
   if (!poster_info.poster_attribute.empty())
     blocked_plugin->BlockForPowerSaverPoster();
-#endif
   blocked_plugin->SetPluginInfo(info);
   blocked_plugin->SetIdentifier(identifier);
   return blocked_plugin;
 }
 
 void ChromePluginPlaceholder::SetStatus(
     ChromeViewHostMsg_GetPluginInfo_Status status) {
   status_ = status;
 }
 
@@ skipping 105 matching lines @@
   }
 }
 
 void ChromePluginPlaceholder::OnMenuAction(int request_id, unsigned action) {
   DCHECK_EQ(context_menu_request_id_, request_id);
   if (g_last_active_menu != this)
     return;
   switch (action) {
     case chrome::MENU_COMMAND_PLUGIN_RUN: {
       RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Load_Menu"));
-#if defined(ENABLE_PLUGINS)
       MarkPluginEssential(
           content::PluginInstanceThrottler::UNTHROTTLE_METHOD_BY_CLICK);
-#endif
       LoadPlugin();
       break;
     }
     case chrome::MENU_COMMAND_PLUGIN_HIDE: {
       RenderThread::Get()->RecordAction(UserMetricsAction("Plugin_Hide_Menu"));
       HidePlugin();
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void ChromePluginPlaceholder::OnMenuClosed(int request_id) {
   DCHECK_EQ(context_menu_request_id_, request_id);
   context_menu_request_id_ = 0;
 }
 
+v8::Local<v8::Value> ChromePluginPlaceholder::GetV8Handle(
+    v8::Isolate* isolate) {
+  return gin::CreateHandle(isolate, this).ToV8();
+}
+
 void ChromePluginPlaceholder::ShowContextMenu(const WebMouseEvent& event) {
-#if !defined(OS_ANDROID)  // The context menu is not applicable on Android.
   if (context_menu_request_id_)
     return;  // Don't allow nested context menu requests.
 
   content::ContextMenuParams params;
 
   if (!title_.empty()) {
     content::MenuItem name_item;
     name_item.label = title_;
     params.custom_items.push_back(name_item);
 
@@ skipping 15 matching lines @@
   hide_item.action = chrome::MENU_COMMAND_PLUGIN_HIDE;
   hide_item.enabled = true;
   hide_item.label = l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PLUGIN_HIDE);
   params.custom_items.push_back(hide_item);
 
   params.x = event.windowX;
   params.y = event.windowY;
 
   context_menu_request_id_ = render_frame()->ShowContextMenu(this, params);
   g_last_active_menu = this;
-#endif  // OS_ANDROID
 }
 
 blink::WebPlugin* ChromePluginPlaceholder::CreatePlugin() {
   scoped_ptr<content::PluginInstanceThrottler> throttler;
-#if defined(ENABLE_PLUGINS)
   // If the plugin has already been marked essential in its placeholder form,
   // we shouldn't create a new throttler and start the process all over again.
   if (power_saver_enabled()) {
     throttler = content::PluginInstanceThrottler::Create();
     // PluginPreroller manages its own lifetime.
     new PluginPreroller(render_frame(), GetFrame(), GetPluginParams(),
                         GetPluginInfo(), GetIdentifier(), title_,
                         l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, title_),
                         throttler.get());
   }
-#endif
   return render_frame()->CreatePlugin(GetFrame(), GetPluginInfo(),
                                       GetPluginParams(), throttler.Pass());
 }
 
 gin::ObjectTemplateBuilder ChromePluginPlaceholder::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
-  return LoadablePluginPlaceholder::GetObjectTemplateBuilder(isolate).SetMethod(
-      "openAboutPlugins", &ChromePluginPlaceholder::OpenAboutPluginsCallback);
+  return gin::Wrappable<ChromePluginPlaceholder>::GetObjectTemplateBuilder(
+             isolate)
+      .SetMethod<void (ChromePluginPlaceholder::*)()>(
+           "hide", &ChromePluginPlaceholder::HideCallback)
+      .SetMethod<void (ChromePluginPlaceholder::*)()>(
+           "load", &ChromePluginPlaceholder::LoadCallback)
+      .SetMethod<void (ChromePluginPlaceholder::*)()>(
+           "didFinishLoading",
+           &ChromePluginPlaceholder::DidFinishLoadingCallback)
+      .SetMethod("openAboutPlugins",
+                 &ChromePluginPlaceholder::OpenAboutPluginsCallback);
 }