Don't load plugins on prerendered pages until the pages are displayed....

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 1007 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_DisplayPrerenderedPage,
+                        OnDisplayPrerenderedPage)
     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 408 matching lines @@
 
     if (!params.extra_headers.empty()) {
       for (net::HttpUtil::HeadersIterator i(params.extra_headers.begin(),
                                             params.extra_headers.end(), "\n");
            i.GetNext(); ) {
         request.addHTTPHeaderField(WebString::fromUTF8(i.name()),
                                    WebString::fromUTF8(i.values()));
       }
     }
 
-    if (navigation_state)
-      navigation_state->set_load_type(NavigationState::NORMAL_LOAD);
+    if (navigation_state) {
+      if (params.navigation_type != ViewMsg_Navigate_Params::PRERENDER) {
+        navigation_state->set_load_type(NavigationState::NORMAL_LOAD);
+      } else {
+        navigation_state->set_load_type(NavigationState::PRERENDER_LOAD);
+        navigation_state->set_is_prerendering(true);
+      }
+    }
     main_frame->loadRequest(request);
   }
 
   // In case LoadRequest failed before DidCreateDataSource was called.
   pending_navigation_state_.reset();
 }
 
 // Stop loading the current page
 void RenderView::OnStop() {
   if (webview())
@@ skipping 1234 matching lines @@
 
   if (group->IsVulnerable() &&
       !cmd->HasSwitch(switches::kAllowOutdatedPlugins)) {
     Send(new ViewHostMsg_BlockedOutdatedPlugin(routing_id_,
                                                group->GetGroupName(),
                                                GURL(group->GetUpdateURL())));
     return CreatePluginPlaceholder(frame,
                                    params,
                                    *group,
                                    IDR_BLOCKED_PLUGIN_HTML,
-                                   IDS_PLUGIN_OUTDATED);
+                                   IDS_PLUGIN_OUTDATED,
+                                   false);
   }
 
   if (!info.enabled)
     return NULL;
 
   ContentSetting host_setting =
       current_content_settings_.settings[CONTENT_SETTINGS_TYPE_PLUGINS];
   if (info.path.value() == webkit::npapi::kDefaultPluginLibraryName ||
       plugin_setting == CONTENT_SETTING_ALLOW ||
       host_setting == CONTENT_SETTING_ALLOW) {
+    // Delay loading plugins if prerendering.
+    WebDataSource* ds = frame->dataSource();
+    NavigationState* navigation_state = NavigationState::FromDataSource(ds);
+    if (navigation_state->is_prerendering()) {
+      return CreatePluginPlaceholder(frame,
+                                     params,
+                                     *group,
+                                     IDR_CLICK_TO_PLAY_PLUGIN_HTML,
+                                     IDS_PLUGIN_LOAD,
+                                     true);
+    }
+
     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, actual_mime_type);
   }
   std::string resource;
   if (cmd->HasSwitch(switches::kEnableResourceContentSettings))
     resource = group->identifier();
   DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS, resource);
   if (plugin_setting == CONTENT_SETTING_ASK) {
     return CreatePluginPlaceholder(frame,
                                    params,
                                    *group,
                                    IDR_CLICK_TO_PLAY_PLUGIN_HTML,
-                                   IDS_PLUGIN_LOAD);
+                                   IDS_PLUGIN_LOAD,
+                                   false);
   } else {
     return CreatePluginPlaceholder(frame,
                                    params,
                                    *group,
                                    IDR_BLOCKED_PLUGIN_HTML,
-                                   IDS_PLUGIN_BLOCKED);
+                                   IDS_PLUGIN_BLOCKED,
+                                   false);
   }
 }
 
 WebWorker* RenderView::createWorker(WebFrame* frame, WebWorkerClient* client) {
   WebApplicationCacheHostImpl* appcache_host =
       WebApplicationCacheHostImpl::FromFrame(frame);
   int appcache_host_id = appcache_host ? appcache_host->host_id() : 0;
   return new WebWorkerProxy(client, RenderThread::current(), routing_id_,
                             appcache_host_id);
 }
@@ skipping 1614 matching lines @@
     const std::string& mime_type) {
   return new webkit::npapi::WebPluginImpl(
       frame, params, path, mime_type, AsWeakPtr());
 }
 
 WebPlugin* RenderView::CreatePluginPlaceholder(
     WebFrame* frame,
     const WebPluginParams& params,
     const webkit::npapi::PluginGroup& group,
     int resource_id,
-    int message_id) {
+    int message_id,
+    bool is_blocked_for_prerendering) {
   // |blocked_plugin| will delete itself when the WebViewPlugin
   // is destroyed.
   BlockedPlugin* blocked_plugin =
       new BlockedPlugin(this,
                         frame,
                         group,
                         params,
                         webkit_preferences_,
                         resource_id,
                         l10n_util::GetStringFUTF16(message_id,
-                                                   group.GetGroupName()));
+                                                   group.GetGroupName()),
+                        is_blocked_for_prerendering);
   return blocked_plugin->plugin();
 }
 
 void RenderView::OnZoom(PageZoom::Function function) {
   if (!webview())  // Not sure if this can happen, but no harm in being safe.
     return;
 
   webview()->hidePopups();
 
   double old_zoom_level = webview()->zoomLevel();
@@ skipping 271 matching lines @@
 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::OnDisplayPrerenderedPage() {
+  NavigationState* navigation_state = pending_navigation_state_.get();
+  if (!navigation_state) {
+    WebDataSource* ds = webview()->mainFrame()->dataSource();
+    navigation_state = NavigationState::FromDataSource(ds);
+  }
+
+  DCHECK(navigation_state->is_prerendering());
+  navigation_state->set_is_prerendering(false);
+}
+
 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();
 }