Remove throttling code from the Browser process and...

chrome/renderer/render_view.h

 // 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.
 
 #ifndef CHROME_RENDERER_RENDER_VIEW_H_
 #define CHROME_RENDERER_RENDER_VIEW_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 33 matching lines @@
 class WebError;
 class WebFrame;
 class WebPluginDelegate;
 class WebPluginDelegateProxy;
 enum WebRequestCachePolicy;
 
 namespace webkit_glue {
   struct FileUploadData;
 }
 
+// We need to prevent a page from trying to create infinite popups. It is not
+// as simple as keeping a count of the number of immediate children
+// popups. Having an html file that window.open()s itself would create
+// an unlimited chain of RenderViews who only have one RenderView child.
+//
+// Therefore, each new top level RenderView creates a new counter and shares it
+// with all its children and grandchildren popup RenderViews created with
+// CreateWebView() to have a sort of global limit for the page so no more than
+// kMaximumNumberOfPopups popups are created.
+//
+// This is a RefCounted holder of an int because I can't say
+// scoped_refptr<int>.
+typedef base::RefCountedData<int> SharedRenderViewCounter;
+
 //
 // RenderView is an object that manages a WebView object, and provides a
 // communication interface with an embedding application process
 //
 class RenderView : public RenderWidget, public WebViewDelegate,
                    public webkit_glue::DomSerializerDelegate {
  public:
   // Creates a new RenderView.  The parent_hwnd specifies a HWND to use as the
   // parent of the WebView HWND that will be created.  The modal_dialog_event
   // is set by the RenderView whenever a modal dialog alert is shown, so that
   // the renderer and plugin processes know to pump window messages.  If this
   // is a constrained popup or as a new tab, opener_id is the routing ID of the
   // RenderView responsible for creating this RenderView (corresponding to the
-  // parent_hwnd).
-  static RenderView* Create(HWND parent_hwnd,
-                            HANDLE modal_dialog_event,
-                            int32 opener_id,
-                            const WebPreferences& webkit_prefs,
-                            int32 routing_id);
+  // parent_hwnd). |counter| is either a currently initialized counter, or NULL
+  // (in which case we treat this RenderView as a top level window).
+  static RenderView* Create(
+      HWND parent_hwnd,
+      HANDLE modal_dialog_event,
+      int32 opener_id,
+      const WebPreferences& webkit_prefs,
+      SharedRenderViewCounter* counter,
+      int32 routing_id);
 
   // Sets the "next page id" counter.
   static void SetNextPageID(int32 next_page_id);
 
   // The resource dispatcher used to fetch resources for this view.
   ResourceDispatcher* resource_dispatcher() {
     return resource_dispatcher_;
   }
 
   // May return NULL when the view is closing.
@@ skipping 203 matching lines @@
   // constructor stores that view ID.
   explicit RenderView(int32 opener_id);
 
   // Initializes this view with the given parent and ID. The |routing_id| can be
   // set to 'MSG_ROUTING_NONE' if the true ID is not yet known. In this case,
   // CompleteInit must be called later with the true ID.
   void Init(HWND parent,
             HANDLE modal_dialog_event,
             int32 opener_id,
             const WebPreferences& webkit_prefs,
+            SharedRenderViewCounter* counter,
             int32 routing_id);
 
   void UpdateURL(WebFrame* frame);
   void UpdateTitle(WebFrame* frame, const std::wstring& title);
   void UpdateSessionHistory(WebFrame* frame);
 
   // Update current main frame's encoding and send it to browser window.
   // Since we want to let users see the right encoding info from menu
   // before finishing loading, we call the UpdateEncoding in
   // a) function:DidCommitLoadForFrame. When this function is called,
@@ skipping 130 matching lines @@
   void OnThemeChanged();
 
 #ifdef CHROME_PERSONALIZATION
   void OnPersonalizationEvent(std::string event_name, std::string event_args);
 #endif
 
   // Handles messages posted from automation.
   void OnMessageFromExternalHost(const std::string& target,
                                  const std::string& message);
 
+  // Message that we should no longer be part of the current popup window
+  // grouping, and should form our own grouping.
+  void OnDisassociateFromPopupCount();
+
   // Switches the frame's CSS media type to "print" and calculate the number of
   // printed pages that are to be expected. |frame| will be used to calculate
   // the number of expected pages for this frame only.
   int SwitchFrameToPrintMediaType(const ViewMsg_Print_Params& params,
                                   WebFrame* frame);
 
   // Switches the frame's CSS media type to "display".
   void SwitchFrameToDisplayMediaType(WebFrame* frame);
 
   // Prints the page listed in |params|.
@@ skipping 154 matching lines @@
 
   int history_back_list_count_;
   int history_forward_list_count_;
 
   // True if pop-up blocking is disabled.  False by default.
   bool disable_popup_blocking_;
 
   // True if the page has any frame-level unload or beforeunload listeners.
   bool has_unload_listener_;
 
+  // The total number of unrequested popups that exist and can be followed back
+  // to a common opener. This count is shared among all RenderViews created
+  // with CreateWebView(). All popups are treated as unrequested until
+  // specifically instructed otherwise by the Browser process.
+  scoped_refptr<SharedRenderViewCounter> shared_popup_counter_;
+
+  // Whether this is a top level window (instead of a popup). Top level windows
+  // shouldn't count against their own |shared_popup_counter_|.
+  bool decrement_shared_popup_at_destruction_;
+
   // Handles accessibility requests into the renderer side, as well as
   // maintains the cache and other features of the accessibility tree.
   scoped_ptr<GlueAccessibility> glue_accessibility_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderView);
 };
 
 #endif  // CHROME_RENDERER_RENDER_VIEW_H_