Remove rendundant WebLocalFrame parameter in various plugin code.

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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 31 matching lines @@
 #include "ui/base/webui/jstemplate_builder.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/origin.h"
 #include "url/url_util.h"
 
 using base::UserMetricsAction;
 using content::RenderThread;
 using content::RenderView;
 
 namespace {
-const ChromePluginPlaceholder* g_last_active_menu = NULL;
+const ChromePluginPlaceholder* g_last_active_menu = nullptr;
 }  // namespace
 
 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),
       status_(ChromeViewHostMsg_GetPluginInfo_Status::kAllowed),
       title_(title),
       context_menu_request_id_(0),
       did_send_blocked_content_notification_(false) {
   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 (placeholder_routing_id_ == MSG_ROUTING_NONE)
     return;
   RenderThread::Get()->RemoveRoute(placeholder_routing_id_);
 }
 
 // TODO(bauerb): Move this method to NonLoadablePluginPlaceholder?
 // static
 ChromePluginPlaceholder* ChromePluginPlaceholder::CreateLoadableMissingPlugin(
     content::RenderFrame* render_frame,
-    blink::WebLocalFrame* frame,
     const blink::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);
 
   // Will destroy itself when its WebViewPlugin is going away.
-  return new ChromePluginPlaceholder(render_frame, frame, params, html_data,
+  return new ChromePluginPlaceholder(render_frame, params, html_data,
                                      params.mime_type.Utf16());
 }
 
 // static
 ChromePluginPlaceholder* ChromePluginPlaceholder::CreateBlockedPlugin(
     content::RenderFrame* render_frame,
-    blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params,
     const content::WebPluginInfo& info,
     const std::string& identifier,
     const base::string16& name,
     int template_id,
     const base::string16& message,
     const PowerSaverInfo& power_saver_info) {
   base::DictionaryValue values;
   values.SetString("message", message);
   values.SetString("name", name);
   values.SetString("hide", l10n_util::GetStringUTF8(IDS_PLUGIN_HIDE));
   values.SetString(
       "pluginType",
-      frame->View()->MainFrame()->IsWebLocalFrame() &&
-              frame->View()->MainFrame()->GetDocument().IsPluginDocument()
+      render_frame->IsMainFrame() &&
+              render_frame->GetWebFrame()->GetDocument().IsPluginDocument()
           ? "document"
           : "embedded");
 
   if (!power_saver_info.poster_attribute.empty()) {
     values.SetString("poster", power_saver_info.poster_attribute);
     values.SetString("baseurl", power_saver_info.base_url.spec());
 
     if (!power_saver_info.custom_poster_size.IsEmpty()) {
-      float zoom_factor =
-          blink::WebView::ZoomLevelToZoomFactor(frame->View()->ZoomLevel());
+      float zoom_factor = blink::WebView::ZoomLevelToZoomFactor(
+          render_frame->GetWebFrame()->View()->ZoomLevel());
       int width =
           roundf(power_saver_info.custom_poster_size.width() / zoom_factor);
       int height =
           roundf(power_saver_info.custom_poster_size.height() / zoom_factor);
       values.SetString("visibleWidth", base::IntToString(width) + "px");
       values.SetString("visibleHeight", base::IntToString(height) + "px");
     }
   }
 
   const base::StringPiece template_html(
       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);
+  ChromePluginPlaceholder* blocked_plugin =
+      new ChromePluginPlaceholder(render_frame, params, html_data, name);
 
   if (!power_saver_info.poster_attribute.empty())
     blocked_plugin->BlockForPowerSaverPoster();
   blocked_plugin->SetPluginInfo(info);
   blocked_plugin->SetIdentifier(identifier);
 
   blocked_plugin->set_power_saver_enabled(power_saver_info.power_saver_enabled);
   blocked_plugin->set_blocked_for_background_tab(
       power_saver_info.blocked_for_background_tab);
 
@@ skipping 59 matching lines @@
   SetMessage(l10n_util::GetStringFUTF16(IDS_PLUGIN_DOWNLOAD_ERROR_SHORT,
                                         plugin_name_));
 }
 
 void ChromePluginPlaceholder::OnSetPrerenderMode(
     prerender::PrerenderMode mode) {
   OnSetIsPrerendering(mode != prerender::NO_PRERENDER);
 }
 
 void ChromePluginPlaceholder::PluginListChanged() {
-  if (!GetFrame() || !plugin())
+  if (!render_frame() || !plugin())
     return;
 
-  // Checking with GetFrame() is equivalent to checking render_frame().
-  DCHECK(render_frame());
-
   ChromeViewHostMsg_GetPluginInfo_Output output;
   std::string mime_type(GetPluginParams().mime_type.Utf8());
   render_frame()->Send(new ChromeViewHostMsg_GetPluginInfo(
       routing_id(), GURL(GetPluginParams().url),
-      GetFrame()->Top()->GetSecurityOrigin(), mime_type, &output));
+      render_frame()->GetWebFrame()->Top()->GetSecurityOrigin(), mime_type,
+      &output));
   if (output.status == status_)
     return;
   blink::WebPlugin* new_plugin = ChromeContentRendererClient::CreatePlugin(
-      render_frame(), GetFrame(), GetPluginParams(), output);
+      render_frame(), GetPluginParams(), output);
   ReplacePlugin(new_plugin);
   if (!new_plugin) {
     PluginUMAReporter::GetInstance()->ReportPluginMissing(
         GetPluginParams().mime_type.Utf8(), GURL(GetPluginParams().url));
   }
 }
 
 void ChromePluginPlaceholder::OnMenuAction(int request_id, unsigned action) {
   DCHECK_EQ(context_menu_request_id_, request_id);
   if (g_last_active_menu != this)
@@ skipping 65 matching lines @@
     enable_flash_item.action = chrome::MENU_COMMAND_ENABLE_FLASH;
     enable_flash_item.enabled = true;
     enable_flash_item.label =
         l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_ENABLE_FLASH);
     params.custom_items.push_back(enable_flash_item);
   }
 
   content::MenuItem hide_item;
   hide_item.action = chrome::MENU_COMMAND_PLUGIN_HIDE;
   bool is_main_frame_plugin_document =
-      GetFrame()->View()->MainFrame()->IsWebLocalFrame() &&
-      GetFrame()->View()->MainFrame()->GetDocument().IsPluginDocument();
+      render_frame()->IsMainFrame() &&
+      render_frame()->GetWebFrame()->GetDocument().IsPluginDocument();
   hide_item.enabled = !is_main_frame_plugin_document;
   hide_item.label = l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PLUGIN_HIDE);
   params.custom_items.push_back(hide_item);
 
   blink::WebPoint point(event.PositionInWidget().x, event.PositionInWidget().y);
   if (plugin() && plugin()->Container())
     point = plugin()->Container()->LocalToRootFramePoint(point);
 
   params.x = point.x;
   params.y = point.y;
 
   context_menu_request_id_ = render_frame()->ShowContextMenu(this, params);
   g_last_active_menu = this;
 }
 
 blink::WebPlugin* ChromePluginPlaceholder::CreatePlugin() {
   std::unique_ptr<content::PluginInstanceThrottler> throttler;
   // 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(
         heuristic_run_before_ ? content::RenderFrame::DONT_RECORD_DECISION
                               : content::RenderFrame::RECORD_DECISION);
     // PluginPreroller manages its own lifetime.
-    new PluginPreroller(render_frame(), GetFrame(), GetPluginParams(),
-                        GetPluginInfo(), GetIdentifier(), title_,
+    new PluginPreroller(render_frame(), GetPluginParams(), GetPluginInfo(),
+                        GetIdentifier(), title_,
                         l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, title_),
                         throttler.get());
   }
-  return render_frame()->CreatePlugin(GetFrame(), GetPluginInfo(),
-                                      GetPluginParams(), std::move(throttler));
+  return render_frame()->CreatePlugin(GetPluginInfo(), GetPluginParams(),
+                                      std::move(throttler));
 }
 
 void ChromePluginPlaceholder::OnBlockedTinyContent() {
   DCHECK(render_frame());
   if (did_send_blocked_content_notification_)
     return;
 
   did_send_blocked_content_notification_ = true;
   ContentSettingsObserver::Get(render_frame())
       ->DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS, title_);
@@ skipping 15 matching lines @@
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePluginPlaceholderTesting)) {
     builder.SetMethod<void (ChromePluginPlaceholder::*)()>(
         "didFinishIconRepositionForTesting",
         &ChromePluginPlaceholder::DidFinishIconRepositionForTestingCallback);
   }
 
   return builder;
 }