Blocking resource request for hidden page when interstitial showing

chrome/browser/renderer_host/resource_dispatcher_host.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.
 
 // This is the browser side of the resource dispatcher, it receives requests
 // from the RenderProcessHosts, and dispatches them to URLRequests. It then
 // fowards the messages from the URLRequests back to the correct process for
 // handling.
 //
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #ifndef CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_
 #define CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_
 
 #include <map>
 #include <string>
+#include <vector>
 
 #include "base/logging.h"
 #include "base/observer_list.h"
 #include "base/ref_counted.h"
 #include "base/timer.h"
 #include "chrome/browser/renderer_host/resource_handler.h"
 #include "chrome/common/filter_policy.h"
 #include "chrome/common/ipc_message.h"
 #include "net/url_request/url_request.h"
 #include "webkit/glue/resource_type.h"
@@ skipping 168 matching lines @@
   //
   void BeginRequest(Receiver* receiver,
                     HANDLE render_process_handle,
                     int render_process_host_id,
                     int render_view_id,
                     int request_id,
                     const ViewHostMsg_Resource_Request& request,
                     URLRequestContext* request_context,
                     IPC::Message* sync_result);
 
-  // Initiate a download from the browser process (as opposed to a resource
+  // Initiates a download from the browser process (as opposed to a resource
   // request from the renderer).
   void BeginDownload(const GURL& url,
                      const GURL& referrer,
                      int render_process_host_id,
                      int render_view_id,
                      URLRequestContext* request_context);
 
-  // Initiate a save file from the browser process (as opposed to a resource
+  // Initiates a save file from the browser process (as opposed to a resource
   // request from the renderer).
   void BeginSaveFile(const GURL& url,
                      const GURL& referrer,
                      int render_process_host_id,
                      int render_view_id,
                      URLRequestContext* request_context);
 
   // Cancels the given request if it still exists. We ignore cancels from the
   // renderer in the event of a download.
   void CancelRequest(int render_process_host_id,
@@ skipping 70 matching lines @@
     return r;
   }
 
   static const ExtraRequestInfo* ExtraInfoForRequest(const URLRequest* request) {
     const ExtraRequestInfo* r =
         static_cast<const ExtraRequestInfo*>(request->user_data());
     DLOG_IF(WARNING, !r) << "Request doesn't seem to have our data";
     return r;
   }
 
-  // Add an observer.  The observer will be called on the IO thread.  To
+  // Adds an observer.  The observer will be called on the IO thread.  To
   // observe resource events on the UI thread, subscribe to the
   // NOTIFY_RESOURCE_* notifications of the notification service.
   void AddObserver(Observer* obs);
 
-  // Remove an observer.
+  // Removes an observer.
   void RemoveObserver(Observer* obs);
 
   // Retrieves a URLRequest.  Must be called from the IO thread.
   URLRequest* GetURLRequest(GlobalRequestID request_id) const;
 
   // A test to determining whether a given request should be forwarded to the
   // download thread.
   bool ShouldDownload(const std::string& mime_type,
                       const std::string& content_disposition);
 
-  // Notify our observers that a request has been cancelled.
+  // Notifies our observers that a request has been cancelled.
   void NotifyResponseCompleted(URLRequest* request, int render_process_host_id);
 
   void RemovePendingRequest(int render_process_host_id, int request_id);
 
+  // Causes all new requests for the render view identified by
+  // |render_process_host_id| and |render_view_id| to be blocked (not being
+  // started) until ResumeBlockedRequestsForRenderView or
+  // CancelBlockedRequestsForRenderView is called.
+  void BlockRequestsForRenderView(int render_process_host_id,
+                                  int render_view_id);
+
+  // Resumes any blocked request for the specified RenderView.
+  void ResumeBlockedRequestsForRenderView(int render_process_host_id,
+                                          int render_view_id);
+
+  // Cancels any blocked request for the specified RenderView.
+  void CancelBlockedRequestsForRenderView(int render_process_host_id,
+                                          int render_view_id);
+
  private:
+  FRIEND_TEST(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies);
   class ShutdownTask;
 
   friend class ShutdownTask;
 
+  struct BlockedRequest {
+    BlockedRequest(URLRequest* url_request, bool mixed_content)
+        : url_request(url_request),
+          mixed_content(mixed_content) {
+    }
+    URLRequest* url_request;
+    bool mixed_content;
+  };
+
   // A shutdown helper that runs on the IO thread.
   void OnShutdown();
 
   // Returns true if the request is paused.
   bool PauseRequestIfNeeded(ExtraRequestInfo* info);
 
   // Resumes the given request by calling OnResponseStarted or OnReadCompleted.
   void ResumeRequest(const GlobalRequestID& request_id);
 
   // Reads data from the response using our internal buffer as async IO.
@@ skipping 49 matching lines @@
                               int render_process_host_id,
                               int tab_contents_id,
                               const GURL& url,
                               ResourceType::Type resource_type,
                               ResourceHandler* handler);
 
   void UpdateLoadStates();
 
   void MaybeUpdateUploadProgress(ExtraRequestInfo *info, URLRequest *request);
 
+  // Resumes or cancels (if |cancel_requests| is true) any blocked requests.
+  void ProcessBlockedRequestsForRenderView(int render_process_host_id,
+                                           int render_view_id,
+                                           bool cancel_requests);
+
   PendingRequestList pending_requests_;
 
   // We cache the UI message loop so we can create new UI-related objects on it.
   MessageLoop* ui_loop_;
 
   // We cache the IO loop to ensure that GetURLRequest is only called from the
   // IO thread.
   MessageLoop* io_loop_;
 
   // A timer that periodically calls UpdateLoadStates while pending_requests_
@@ skipping 24 matching lines @@
   ObserverList<Observer> observer_list_;
 
   PluginService* plugin_service_;
 
   // For running tasks.
   ScopedRunnableMethodFactory<ResourceDispatcherHost> method_runner_;
 
   // True if the resource dispatcher host has been shut down.
   bool is_shutdown_;
 
+  typedef std::vector<BlockedRequest> BlockedRequestsList;
+  typedef std::pair<int, int> ProcessRendererIDs;
+  typedef std::map<ProcessRendererIDs, BlockedRequestsList*> BlockedRequestMap;
+  BlockedRequestMap blocked_requests_map_;
+
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcherHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_RESOURCE_DISPATCHER_HOST_H_