Clean up plug-in placeholders:

chrome/renderer/chrome_content_renderer_client.cc

 // Copyright (c) 2011 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/chrome_content_renderer_client.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/autofill/autofill_agent.h"
 #include "chrome/renderer/autofill/password_autofill_manager.h"
 #include "chrome/renderer/automation/automation_renderer_helper.h"
 #include "chrome/renderer/benchmarking_extension.h"
-#include "chrome/renderer/blocked_plugin.h"
 #include "chrome/renderer/chrome_ppapi_interfaces.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/chrome_render_view_observer.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/chrome_v8_extension.h"
 #include "chrome/renderer/extensions/extension_dispatcher.h"
 #include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/extensions/extension_resource_request_policy.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/schema_generated_bindings.h"
 #include "chrome/renderer/external_extension.h"
 #include "chrome/renderer/loadtimes_extension_bindings.h"
 #include "chrome/renderer/localized_error.h"
 #include "chrome/renderer/net/renderer_net_predictor.h"
 #include "chrome/renderer/page_click_tracker.h"
 #include "chrome/renderer/page_load_histograms.h"
-#include "chrome/renderer/plugin_uma.h"
+#include "chrome/renderer/plugins/blocked_plugin.h"
+#include "chrome/renderer/plugins/missing_plugin.h"
+#include "chrome/renderer/plugins/plugin_uma.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "chrome/renderer/print_web_view_helper.h"
 #include "chrome/renderer/renderer_histogram_snapshots.h"
 #include "chrome/renderer/renderer_tracking.h"
 #include "chrome/renderer/safe_browsing/malware_dom_details.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/search_extension.h"
 #include "chrome/renderer/searchbox.h"
 #include "chrome/renderer/searchbox_extension.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
@@ skipping 223 matching lines @@
   ChromeViewHostMsg_GetPluginInfo_Status status;
   webkit::WebPluginInfo plugin;
   std::string actual_mime_type;
   render_view->Send(new ChromeViewHostMsg_GetPluginInfo(
       render_view->GetRoutingId(), url, frame->top()->document().url(),
       orig_mime_type, &status, &plugin, &actual_mime_type));
 
   if (status.value == ChromeViewHostMsg_GetPluginInfo_Status::kNotFound) {
     MissingPluginReporter::GetInstance()->ReportPluginMissing(
         orig_mime_type, url);
-    return CreatePluginPlaceholder(
-        render_view, frame, plugin, original_params, NULL,
-        IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_NOT_FOUND, false, false);
+    return MissingPlugin::Create(render_view, frame, original_params);
   }
   if (plugin.path.value() == webkit::npapi::kDefaultPluginLibraryName) {
     MissingPluginReporter::GetInstance()->ReportPluginMissing(
         orig_mime_type, url);
   }
 
   scoped_ptr<webkit::npapi::PluginGroup> group(
       webkit::npapi::PluginList::Singleton()->GetPluginGroup(plugin));
 
   if (status.value == ChromeViewHostMsg_GetPluginInfo_Status::kDisabled) {
-    return CreatePluginPlaceholder(
-        render_view, frame, plugin, original_params, group.get(),
+    return BlockedPlugin::Create(
+        render_view, frame, original_params, plugin, group.get(),
         IDR_DISABLED_PLUGIN_HTML, IDS_PLUGIN_DISABLED, false, false);
   }
 
   WebPluginParams params(original_params);
   for (size_t i = 0; i < plugin.mime_types.size(); ++i) {
     if (plugin.mime_types[i].mime_type == actual_mime_type) {
       AppendParams(plugin.mime_types[i].additional_param_names,
                    plugin.mime_types[i].additional_param_values,
                    &params.attributeNames,
                    &params.attributeValues);
       break;
     }
   }
 
   if (status.value ==
       ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked) {
     render_view->Send(new ChromeViewHostMsg_BlockedOutdatedPlugin(
         render_view->GetRoutingId(), group->GetGroupName(),
         GURL(group->GetUpdateURL())));
   }
   if (status.value ==
-      ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked ||
+          ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked ||
       status.value ==
           ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedDisallowed) {
-    return CreatePluginPlaceholder(
-        render_view, frame, plugin, params, group.get(),
+    return BlockedPlugin::Create(
+        render_view, frame, params, plugin, group.get(),
         IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_OUTDATED, false,
         status.value ==
-        ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked);
+            ChromeViewHostMsg_GetPluginInfo_Status::kOutdatedBlocked);
   }
 
   ContentSettingsObserver* observer = ContentSettingsObserver::Get(render_view);
 
   if (status.value ==
       ChromeViewHostMsg_GetPluginInfo_Status::kUnauthorized &&
       !observer->plugins_temporarily_allowed()) {
     render_view->Send(new ChromeViewHostMsg_BlockedOutdatedPlugin(
         render_view->GetRoutingId(), group->GetGroupName(), GURL()));
-    return CreatePluginPlaceholder(
-        render_view, frame, plugin, params, group.get(),
+    return BlockedPlugin::Create(
+        render_view, frame, params, plugin, group.get(),
         IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_NOT_AUTHORIZED, false, true);
   }
 
   bool is_nacl_plugin = (plugin.name == ASCIIToUTF16(
       chrome::ChromeContentClient::kNaClPluginName));
   if (status.value == ChromeViewHostMsg_GetPluginInfo_Status::kAllowed ||
       observer->plugins_temporarily_allowed() ||
       plugin.path.value() == webkit::npapi::kDefaultPluginLibraryName) {
     // Delay loading plugins if prerendering.
     if (prerender::PrerenderHelper::IsPrerendering(render_view)) {
-      return CreatePluginPlaceholder(
-          render_view, frame, plugin, params, group.get(),
+      return BlockedPlugin::Create(
+          render_view, frame, params, plugin, group.get(),
           IDR_CLICK_TO_PLAY_PLUGIN_HTML, IDS_PLUGIN_LOAD, true, true);
     }
 
     // Determine if NaCl is allowed for both the internal plugin and
     // any external plugin that handles our MIME type. This is so NaCl
     // tests will still pass.
     const char* kNaClMimeType = "application/x-nacl";
     bool is_nacl_mime_type = actual_mime_type == kNaClMimeType;
     bool is_nacl_enabled;
     if (is_nacl_plugin) {
       is_nacl_enabled = cmd->HasSwitch(switches::kEnableNaCl);
     } else {
       // If this is an external plugin that handles NaCl mime type,
       // we want to allow Native Client, because it's how
       // NaCl tests for the plugin work.
       is_nacl_enabled = true;
     }
     if (is_nacl_plugin || is_nacl_mime_type) {
       if (!IsNaClAllowed(plugin,
                          url,
                          actual_mime_type,
                          is_nacl_mime_type,
                          is_nacl_enabled,
                          params)) {
-        return CreatePluginPlaceholder(
-            render_view, frame, plugin, params, group.get(),
+        return BlockedPlugin::Create(
+            render_view, frame, params, plugin, group.get(),
             IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_BLOCKED, false, false);
       }
     }
 
     return render_view->CreatePlugin(frame, plugin, params);
   }
 
   observer->DidBlockContentType(
       is_nacl_plugin ? CONTENT_SETTINGS_TYPE_JAVASCRIPT :
                        CONTENT_SETTINGS_TYPE_PLUGINS,
       group->identifier());
   if (status.value == ChromeViewHostMsg_GetPluginInfo_Status::kClickToPlay) {
     RenderThread::Get()->RecordUserMetrics("Plugin_ClickToPlay");
-    return CreatePluginPlaceholder(
-        render_view, frame, plugin, params, group.get(),
+    return BlockedPlugin::Create(
+        render_view, frame, params, plugin, group.get(),
         IDR_CLICK_TO_PLAY_PLUGIN_HTML, IDS_PLUGIN_LOAD, false, true);
   } else {
     DCHECK(status.value == ChromeViewHostMsg_GetPluginInfo_Status::kBlocked);
     RenderThread::Get()->RecordUserMetrics("Plugin_Blocked");
-    return CreatePluginPlaceholder(
-        render_view, frame, plugin, params, group.get(),
+    return BlockedPlugin::Create(
+        render_view, frame, params, plugin, group.get(),
         IDR_BLOCKED_PLUGIN_HTML, IDS_PLUGIN_BLOCKED, false, true);
   }
 }
 
 bool ChromeContentRendererClient::IsNaClAllowed(
     const webkit::WebPluginInfo& plugin,
     const GURL& url,
     const std::string& actual_mime_type,
     bool is_nacl_mime_type,
     bool enable_nacl,
@@ skipping 65 matching lines @@
     size_t attribute_count = params.attributeNames.size();
     for (size_t i = 0; i < attribute_count; ++i) {
       if (params.attributeNames[i].equals(dev_attribute))
         params.attributeNames[i] = WebString();
     }
   }
 
   return true;
 }
 
-WebPlugin* ChromeContentRendererClient::CreatePluginPlaceholder(
-    content::RenderView* render_view,
-    WebFrame* frame,
-    const webkit::WebPluginInfo& plugin,
-    const WebPluginParams& params,
-    const webkit::npapi::PluginGroup* group,
-    int resource_id,
-    int message_id,
-    bool is_blocked_for_prerendering,
-    bool allow_loading) {
-  // |blocked_plugin| will delete itself when the WebViewPlugin
-  // is destroyed.
-  string16 name;
-  string16 message;
-  if (group) {
-    name = group->GetGroupName();
-    message = l10n_util::GetStringFUTF16(message_id, name);
-  } else {
-    message = l10n_util::GetStringUTF16(message_id);
-  }
-
-  BlockedPlugin* blocked_plugin =
-      new BlockedPlugin(render_view,
-                        frame,
-                        plugin,
-                        params,
-                        render_view->GetWebkitPreferences(),
-                        resource_id,
-                        name,
-                        message,
-                        is_blocked_for_prerendering,
-                        allow_loading);
-  return blocked_plugin->plugin();
-}
-
 bool ChromeContentRendererClient::HasErrorPage(int http_status_code,
                                                std::string* error_domain) {
   // Use an internal error page, if we have one for the status code.
   if (!LocalizedError::HasStrings(LocalizedError::kHttpErrorDomain,
                                   http_status_code)) {
     return false;
   }
 
   *error_domain = LocalizedError::kHttpErrorDomain;
   return true;
@@ skipping 283 matching lines @@
 bool ChromeContentRendererClient::IsOtherExtensionWithWebRequestInstalled() {
   return extension_dispatcher_->IsOtherExtensionWithWebRequestInstalled();
 }
 
 void ChromeContentRendererClient::RegisterPPAPIInterfaceFactories(
     webkit::ppapi::PpapiInterfaceFactoryManager* factory_manager) {
   factory_manager->RegisterFactory(ChromePPAPIInterfaceFactory);
 }
 
 }  // namespace chrome