Make BlockedPlugin implement RenderViewObserver so that RenderView doesn't ha...

chrome/renderer/render_view.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/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 547 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(page_info_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(accessibility_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(translate_helper_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       devtools_client_(NULL),
       geolocation_dispatcher_(NULL),
       speech_input_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
       accessibility_ack_pending_(false),
       pending_app_icon_requests_(0),
-      session_storage_namespace_id_(session_storage_namespace_id),
-      custom_menu_listener_(NULL) {
+      session_storage_namespace_id_(session_storage_namespace_id) {
 #if defined(OS_MACOSX)
   // On Mac, the select popups are rendered by the browser.
   // Note that we don't do this in RenderMain otherwise this would not be called
   // in single-process mode.
   WebKit::WebView::setUseExternalPopupMenus(true);
 #endif
 
   ClearBlockedContentSettings();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableClientSidePhishingDetection)) {
@@ skipping 344 matching lines @@
   if (!found || !info.enabled)
     return NULL;
 
   scoped_refptr<webkit::ppapi::PluginModule> pepper_module(
       pepper_delegate_.CreatePepperPlugin(info.path));
   if (pepper_module)
     return CreatePepperPlugin(frame, params, info.path, pepper_module.get());
   return CreateNPAPIPlugin(frame, params, info.path, mime_type);
 }
 
-void RenderView::CustomMenuListenerInstall(CustomMenuListener* listening) {
-  custom_menu_listener_ = listening;
-}
-
-void RenderView::CustomMenuListenerDestroyed(CustomMenuListener* dead) {
-  if (custom_menu_listener_ == dead)
-    custom_menu_listener_ = NULL;
-}
-
 void RenderView::RegisterPluginDelegate(WebPluginDelegateProxy* delegate) {
   plugin_delegates_.insert(delegate);
   // If the renderer is visible, set initial visibility and focus state.
   if (!is_hidden()) {
 #if defined(OS_MACOSX)
     delegate->SetContainerVisibility(true);
     if (webview() && webview()->isActive())
       delegate->SetWindowFocus(true);
 #endif
   }
   // Plugins start assuming the content has focus (so that they work in
   // environments where RenderView isn't hosting them), so we always have to
   // set the initial state. See webplugin_delegate_impl.h for details.
   delegate->SetContentAreaFocus(has_focus());
 }
 
 void RenderView::UnregisterPluginDelegate(WebPluginDelegateProxy* delegate) {
   plugin_delegates_.erase(delegate);
 }
 
-void RenderView::RegisterBlockedPlugin(BlockedPlugin* blocked_plugin) {
-  blocked_plugins_.insert(blocked_plugin);
-}
-
-void RenderView::UnregisterBlockedPlugin(BlockedPlugin* blocked_plugin) {
-  blocked_plugins_.erase(blocked_plugin);
-}
-
 bool RenderView::OnMessageReceived(const IPC::Message& message) {
   WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
   if (main_frame)
     child_process_logging::SetActiveURL(main_frame->url());
 
   ObserverListBase<RenderViewObserver>::Iterator it(observers_);
   RenderViewObserver* observer;
   while ((observer = it.GetNext()) != NULL)
     if (observer->OnMessageReceived(message))
       return true;
@@ skipping 55 matching lines @@
                         OnDragSourceEndedOrMoved)
     IPC_MESSAGE_HANDLER(ViewMsg_DragSourceSystemDragEnded,
                         OnDragSourceSystemDragEnded)
     IPC_MESSAGE_HANDLER(ViewMsg_SetInitialFocus, OnSetInitialFocus)
     IPC_MESSAGE_HANDLER(ViewMsg_ScrollFocusedEditableNodeIntoView,
                         OnScrollFocusedEditableNodeIntoView)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateTargetURL_ACK, OnUpdateTargetURLAck)
     IPC_MESSAGE_HANDLER(ViewMsg_UpdateWebPreferences, OnUpdateWebPreferences)
     IPC_MESSAGE_HANDLER(ViewMsg_SetAltErrorPageURL, OnSetAltErrorPageURL)
     IPC_MESSAGE_HANDLER(ViewMsg_InstallMissingPlugin, OnInstallMissingPlugin)
-    IPC_MESSAGE_HANDLER(ViewMsg_LoadBlockedPlugins, OnLoadBlockedPlugins)
     IPC_MESSAGE_HANDLER(ViewMsg_RunFileChooserResponse, OnFileChooserResponse)
     IPC_MESSAGE_HANDLER(ViewMsg_EnableViewSourceMode, OnEnableViewSourceMode)
     IPC_MESSAGE_HANDLER(ViewMsg_GetAllSavableResourceLinksForCurrentPage,
                         OnGetAllSavableResourceLinksForCurrentPage)
     IPC_MESSAGE_HANDLER(
         ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks,
         OnGetSerializedHtmlDataForCurrentPageWithLocalLinks)
     IPC_MESSAGE_HANDLER(ViewMsg_GetApplicationInfo, OnGetApplicationInfo)
     IPC_MESSAGE_HANDLER(ViewMsg_ShouldClose, OnShouldClose)
     IPC_MESSAGE_HANDLER(ViewMsg_ClosePage, OnClosePage)
@@ skipping 1384 matching lines @@
   // response as RunJavaScriptMessage.
   std::wstring ignored_result;
   SendAndRunNestedMessageLoop(new ViewHostMsg_RunBeforeUnloadConfirm(
       routing_id_, frame->url(), UTF16ToWideHack(message), &success,
       &ignored_result));
   return success;
 }
 
 void RenderView::showContextMenu(
     WebFrame* frame, const WebContextMenuData& data) {
-  custom_menu_listener_ = NULL;
   ContextMenuParams params = ContextMenuParams(data);
   if (!params.misspelled_word.empty() && RenderThread::current()) {
     int misspelled_offset, misspelled_length;
     bool spelled_right = RenderThread::current()->spellchecker()->
         SpellCheckWord(
             params.misspelled_word.c_str(), params.misspelled_word.size(),
             document_tag_,
             &misspelled_offset, &misspelled_length,
             &params.dictionary_suggestions);
     if (spelled_right)
@@ skipping 2209 matching lines @@
 void RenderView::OnUpdateWebPreferences(const WebPreferences& prefs) {
   webkit_preferences_ = prefs;
   webkit_preferences_.Apply(webview());
 }
 
 void RenderView::OnSetAltErrorPageURL(const GURL& url) {
   alternate_error_page_url_ = url;
 }
 
 void RenderView::OnCustomContextMenuAction(unsigned action) {
-  if (custom_menu_listener_)
-    custom_menu_listener_->MenuItemSelected(action);
-  else
-    webview()->performCustomContextMenuAction(action);
+  webview()->performCustomContextMenuAction(action);
 }
 
 void RenderView::OnTranslatePage(int page_id,
                                  const std::string& translate_script,
                                  const std::string& source_lang,
                                  const std::string& target_lang) {
   translate_helper_.TranslatePage(page_id, source_lang, target_lang,
                                   translate_script);
 }
 
 void RenderView::OnRevertTranslation(int page_id) {
   translate_helper_.RevertTranslation(page_id);
 }
 
 void RenderView::OnInstallMissingPlugin() {
   // This could happen when the first default plugin is deleted.
   if (first_default_plugin_)
     first_default_plugin_->InstallMissingPlugin();
 }
 
-void RenderView::OnLoadBlockedPlugins() {
-  while (!blocked_plugins_.empty())
-    (*blocked_plugins_.begin())->LoadPlugin();
-}
-
 void RenderView::OnFileChooserResponse(const std::vector<FilePath>& paths) {
   // This could happen if we navigated to a different page before the user
   // closed the chooser.
   if (file_chooser_completions_.empty())
     return;
 
   WebVector<WebString> ws_file_names(paths.size());
   for (size_t i = 0; i < paths.size(); ++i)
     ws_file_names[i] = webkit_glue::FilePathToWebString(paths[i]);
 
@@ skipping 994 matching lines @@
   if (cmd == kJavaScriptStressTestSetStressRunType) {
     v8::Testing::SetStressRunType(static_cast<v8::Testing::StressType>(param));
   } else if (cmd == kJavaScriptStressTestPrepareStressRun) {
     v8::Testing::PrepareStressRun(param);
   }
 }
 
 void RenderView::OnContextMenuClosed() {
   context_menu_node_.reset();
 }