Remove throttling code from the Browser process and...

chrome/renderer/render_view.cc

 // Copyright (c) 2006-2008 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 <string>
 #include <vector>
 
@@ skipping 75 matching lines @@
 static const int kDelayForForcedCaptureMs = 6000;
 
 // How often we will sync the navigation state when the user is changing form
 // elements or scroll position.
 const TimeDelta kDelayForNavigationSync = TimeDelta::FromSeconds(5);
 
 // The next available page ID to use. This ensures that the page IDs are
 // globally unique in the renderer.
 static int32 next_page_id_ = 1;
 
+// The maximum number of popups that can be spawned from one page.
+static const int kMaximumNumberOfUnacknowledgedPopups = 25;
+
 static const char* const kUnreachableWebDataURL =
     "chrome-resource://chromewebdata/";
 
 namespace {
 
 // Associated with browser-initiated navigations to hold tracking data.
 class RenderViewExtraRequestData : public WebRequest::ExtraData {
  public:
   RenderViewExtraRequestData(int32 pending_page_id,
                              PageTransition::Type transition,
@@ skipping 37 matching lines @@
     opened_by_user_gesture_(true),
     enable_dom_automation_(false),
     enable_dom_ui_bindings_(false),
     target_url_status_(TARGET_NONE),
     printed_document_width_(0),
     first_default_plugin_(NULL),
     navigation_gesture_(NavigationGestureUnknown),
     history_back_list_count_(0),
     history_forward_list_count_(0),
     disable_popup_blocking_(false),
-    has_unload_listener_(false) {
+    has_unload_listener_(false),
+    decrement_shared_popup_at_destruction_(false) {
   resource_dispatcher_ = new ResourceDispatcher(this);
 #ifdef CHROME_PERSONALIZATION
   personalization_ = Personalization::CreateRendererPersonalization();
 #endif
 }
 
 RenderView::~RenderView() {
+  if (decrement_shared_popup_at_destruction_)
+    shared_popup_counter_->data--;
+
   resource_dispatcher_->ClearMessageSender();
   // Clear any back-pointers that might still be held by plugins.
   PluginDelegateList::iterator it = plugin_delegates_.begin();
   while (it != plugin_delegates_.end()) {
     (*it)->DropRenderView();
     it = plugin_delegates_.erase(it);
   }
 
   RenderThread::current()->RemoveFilter(debug_message_handler_);
 
 #ifdef CHROME_PERSONALIZATION
   Personalization::CleanupRendererPersonalization(personalization_);
   personalization_ = NULL;
 #endif
 }
 
 /*static*/
-RenderView* RenderView::Create(HWND parent_hwnd,
-                               HANDLE modal_dialog_event,
-                               int32 opener_id,
-                               const WebPreferences& webkit_prefs,
-                               int32 routing_id) {
+RenderView* RenderView::Create(
+    HWND parent_hwnd,
+    HANDLE modal_dialog_event,
+    int32 opener_id,
+    const WebPreferences& webkit_prefs,
+    SharedRenderViewCounter* counter,
+    int32 routing_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
   scoped_refptr<RenderView> view = new RenderView();
   view->Init(parent_hwnd,
              modal_dialog_event,
              opener_id,
              webkit_prefs,
+             counter,
              routing_id);  // adds reference
   return view;
 }
 
 /*static*/
 void RenderView::SetNextPageID(int32 next_page_id) {
   // This method should only be called during process startup, and the given
   // page id had better not exceed our current next page id!
   DCHECK(next_page_id_ == 1);
   DCHECK(next_page_id >= next_page_id_);
@@ skipping 19 matching lines @@
 
 
 void RenderView::JSOutOfMemory() {
   Send(new ViewHostMsg_JSOutOfMemory(routing_id_));
 }
 
 void RenderView::Init(HWND parent_hwnd,
                       HANDLE modal_dialog_event,
                       int32 opener_id,
                       const WebPreferences& webkit_prefs,
+                      SharedRenderViewCounter* counter,
                       int32 routing_id) {
   DCHECK(!webview());
 
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
+  if (counter) {
+    shared_popup_counter_ = counter;
+    shared_popup_counter_->data++;
+    decrement_shared_popup_at_destruction_ = true;
+  } else {
+    shared_popup_counter_ = new SharedRenderViewCounter(0);
+    decrement_shared_popup_at_destruction_ = false;
+  }
+
   // Avoid a leak here by not assigning, since WebView::Create addrefs for us.
   WebWidget* view = WebView::Create(this, webkit_prefs);
   webwidget_.swap(&view);
 
   // Don't let WebCore keep a B/F list - we have our own.
   // We let it keep 1 entry because FrameLoader::goToItem expects an item in the
   // backForwardList, which is used only in ASSERTs.
   webview()->SetBackForwardListSize(1);
 
   routing_id_ = routing_id;
@@ skipping 89 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_ClearAccessibilityInfo,
                         OnClearAccessibilityInfo)
     IPC_MESSAGE_HANDLER(ViewMsg_ShouldClose, OnMsgShouldClose)
     IPC_MESSAGE_HANDLER(ViewMsg_ClosePage, OnClosePage)
     IPC_MESSAGE_HANDLER(ViewMsg_ThemeChanged, OnThemeChanged)
 #ifdef CHROME_PERSONALIZATION
     IPC_MESSAGE_HANDLER(ViewMsg_PersonalizationEvent, OnPersonalizationEvent)
 #endif
     IPC_MESSAGE_HANDLER(ViewMsg_HandleMessageFromExternalHost,
                         OnMessageFromExternalHost)
+    IPC_MESSAGE_HANDLER(ViewMsg_DisassociateFromPopupCount,
+                        OnDisassociateFromPopupCount)
     // Have the super handle all other messages.
     IPC_MESSAGE_UNHANDLED(RenderWidget::OnMessageReceived(message))
   IPC_END_MESSAGE_MAP()
 }
 
 // Got a response from the browser after the renderer decided to create a new
 // view.
 void RenderView::OnCreatingNewAck(HWND parent) {
   CompleteInit(parent);
 }
@@ skipping 1286 matching lines @@
 void RenderView::AddSearchProvider(const std::string& url) {
   AddGURLSearchProvider(GURL(url),
                         false);  // not autodetected
 }
 
 void RenderView::DebuggerOutput(const std::wstring& out) {
   Send(new ViewHostMsg_DebuggerOutput(routing_id_, out));
 }
 
 WebView* RenderView::CreateWebView(WebView* webview, bool user_gesture) {
+  // Check to make sure we aren't overloading on popups.
+  if (shared_popup_counter_->data > kMaximumNumberOfUnacknowledgedPopups)
+    return NULL;
+
   int32 routing_id = MSG_ROUTING_NONE;
   HANDLE modal_dialog_event = NULL;
   bool result = RenderThread::current()->Send(
       new ViewHostMsg_CreateView(routing_id_, user_gesture, &routing_id,
                                  &modal_dialog_event));
   if (routing_id == MSG_ROUTING_NONE) {
     DCHECK(modal_dialog_event == NULL);
     return NULL;
   }
 
   // The WebView holds a reference to this new RenderView
   const WebPreferences& prefs = webview->GetPreferences();
   RenderView* view = RenderView::Create(NULL, modal_dialog_event, routing_id_,
-                                        prefs, routing_id);
+                                        prefs, shared_popup_counter_,
+                                        routing_id);
   view->set_opened_by_user_gesture(user_gesture);
 
   // Copy over the alternate error page URL so we can have alt error pages in
   // the new render view (we don't need the browser to send the URL back down).
   view->alternate_error_page_url_ = alternate_error_page_url_;
 
   return view->webview();
 }
 
 WebWidget* RenderView::CreatePopupWidget(WebView* webview) {
@@ skipping 876 matching lines @@
   script += "'";
   script += ");void(0);";
 
   GURL script_url(script);
   scoped_ptr<WebRequest> request(WebRequest::Create(script_url));
   // TODO(iyengar)
   // Need a mechanism to send results back.
   main_frame->LoadRequest(request.get());
 }
 
+void RenderView::OnDisassociateFromPopupCount() {
+  if (decrement_shared_popup_at_destruction_)
+    shared_popup_counter_->data--;
+  shared_popup_counter_ = new SharedRenderViewCounter(0);
+  decrement_shared_popup_at_destruction_ = false;
+}
+
 std::string RenderView::GetAltHTMLForTemplate(
     const DictionaryValue& error_strings, int template_resource_id) const {
   const StringPiece template_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           template_resource_id));
 
   if (template_html.empty()) {
     NOTREACHED() << "unable to load template. ID: " << template_resource_id;
     return "";
   }
   // "t" is the id of the templates root node.
   return jstemplate_builder::GetTemplateHtml(
       template_html, &error_strings, "t");
 }
-