Blocking resource request for hidden page when interstitial showing

chrome/browser/renderer_host/resource_dispatcher_host_unittest.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 <vector>
 
 #include "base/message_loop.h"
 #include "chrome/browser/renderer_security_policy.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/common/render_messages.h"
@@ skipping 33 matching lines @@
 // We may want to move this to a shared space if it is useful for something else
 class ResourceIPCAccumulator {
  public:
   void AddMessage(const IPC::Message& msg) {
     messages_.push_back(msg);
   }
 
   // This groups the messages by their request ID. The groups will be in order
   // that the first message for each request ID was received, and the messages
   // within the groups will be in the order that they appeared.
+  // Note that this clears messages_.
   typedef std::vector< std::vector<IPC::Message> > ClassifiedMessages;
   void GetClassifiedMessages(ClassifiedMessages* msgs);
 
   std::vector<IPC::Message> messages_;
 };
 
 // This is very inefficient as a result of repeatedly extracting the ID, use
 // only for tests!
 void ResourceIPCAccumulator::GetClassifiedMessages(ClassifiedMessages* msgs) {
   while (!messages_.empty()) {
     std::vector<IPC::Message> cur_requests;
     cur_requests.push_back(messages_[0]);
     int cur_id = RequestIDForMessage(messages_[0]);
 
     // find all other messages with this ID
     for (int i = 1; i < static_cast<int>(messages_.size()); i++) {
       int id = RequestIDForMessage(messages_[i]);
       if (id == cur_id) {
         cur_requests.push_back(messages_[i]);
         messages_.erase(messages_.begin() + i);
-        i --;
+        i--;
       }
     }
     messages_.erase(messages_.begin());
     msgs->push_back(cur_requests);
   }
 }
 
 class ResourceDispatcherHostTest : public testing::Test,
                                    public ResourceDispatcherHost::Receiver {
  public:
@@ skipping 14 matching lines @@
     EnsureTestSchemeIsAllowed();
   }
   virtual void TearDown() {
     URLRequest::RegisterProtocolFactory("test", NULL);
     RendererSecurityPolicy::GetInstance()->Remove(0);
 
     // Flush the message loop to make Purify happy.
     message_loop_.RunAllPending();
   }
 
-  void MakeTestRequest(int request_id, const GURL& url);
+  void MakeTestRequest(int render_process_id,
+                       int render_view_id,
+                       int request_id,
+                       const GURL& url);
   void MakeCancelRequest(int request_id);
 
   void EnsureTestSchemeIsAllowed() {
     static bool have_white_listed_test_scheme = false;
 
     if (!have_white_listed_test_scheme) {
       RendererSecurityPolicy::GetInstance()->RegisterWebSafeScheme("test");
       have_white_listed_test_scheme = true;
     }
   }
 
   MessageLoopForIO message_loop_;
   ResourceDispatcherHost host_;
   ResourceIPCAccumulator accum_;
 };
 
 // Spin up the message loop to kick off the request.
 static void KickOffRequest() {
   MessageLoop::current()->RunAllPending();
 }
 
-void ResourceDispatcherHostTest::MakeTestRequest(int request_id,
+void ResourceDispatcherHostTest::MakeTestRequest(int render_process_id,
+                                                 int render_view_id,
+                                                 int request_id,
                                                  const GURL& url) {
   ViewHostMsg_Resource_Request request = CreateResourceRequest("GET", url);
 
-  host_.BeginRequest(this, GetCurrentProcess(), 0, MSG_ROUTING_NONE,
-                     request_id, request, NULL, NULL);
+  host_.BeginRequest(this, GetCurrentProcess(), render_process_id,
+                     render_view_id, request_id, request, NULL, NULL);
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::MakeCancelRequest(int request_id) {
   host_.CancelRequest(0, request_id, false);
 }
 
 void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages,
                             const std::string& reference_data) {
   // A successful request will have received 4 messages:
@@ skipping 29 matching lines @@
 
   // followed by a 0-byte read
   //ASSERT_EQ(ViewMsg_Resource_DataReceived::ID, messages[2].type());
 
   // the last message should be all data received
   ASSERT_EQ(ViewMsg_Resource_RequestComplete::ID, messages[2].type());
 }
 
 // Tests whether many messages get dispatched properly.
 TEST_F(ResourceDispatcherHostTest, TestMany) {
-  MakeTestRequest(1, URLRequestTestJob::test_url_1());
-  MakeTestRequest(2, URLRequestTestJob::test_url_2());
-  MakeTestRequest(3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(0, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 0, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 3, URLRequestTestJob::test_url_3());
 
   // flush all the pending requests
   while (URLRequestTestJob::ProcessOnePendingMessage());
 
   // sorts out all the messages we saw by request
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // there are three requests, so we should have gotten them classified as such
   ASSERT_EQ(3, msgs.size());
 
   CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[2], URLRequestTestJob::test_data_3());
 }
 
 // Tests whether messages get canceled properly. We issue three requests,
 // cancel one of them, and make sure that each sent the proper notifications.
 TEST_F(ResourceDispatcherHostTest, Cancel) {
   ResourceDispatcherHost host(NULL);
 
-  MakeTestRequest(1, URLRequestTestJob::test_url_1());
-  MakeTestRequest(2, URLRequestTestJob::test_url_2());
-  MakeTestRequest(3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(0, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 0, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 3, URLRequestTestJob::test_url_3());
   MakeCancelRequest(2);
 
   // flush all the pending requests
   while (URLRequestTestJob::ProcessOnePendingMessage());
 
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // there are three requests, so we should have gotten them classified as such
   ASSERT_EQ(3, msgs.size());
@@ skipping 47 matching lines @@
 
   // request 1 goes to the test delegate
   ViewHostMsg_Resource_Request request =
       CreateResourceRequest("GET", URLRequestTestJob::test_url_1());
 
   host_.BeginRequest(&test_receiver, GetCurrentProcess(), 0, MSG_ROUTING_NONE,
                      1, request, NULL, NULL);
   KickOffRequest();
 
   // request 2 goes to us
-  MakeTestRequest(2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 2, URLRequestTestJob::test_url_2());
 
   // request 3 goes to the test delegate
   request.url = URLRequestTestJob::test_url_3();
   host_.BeginRequest(&test_receiver, GetCurrentProcess(), 0, MSG_ROUTING_NONE,
                      3, request, NULL, NULL);
   KickOffRequest();
 
   // TODO: mbelshe
   // Now that the async IO path is in place, the IO always completes on the
   // initial call; so the requests have already completed.  This basically
@@ skipping 16 matching lines @@
   // the test delegate should not have gotten any messages after being canceled
   ASSERT_EQ(0, test_receiver.received_after_canceled_);
 
   // we should have gotten exactly one result
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1, msgs.size());
   CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_2());
 }
 
+// Tests blocking and resuming requests.
+TEST_F(ResourceDispatcherHostTest, TestBlockingResumingRequests) {
+  host_.BlockRequestsForRenderView(0, 1);
+  host_.BlockRequestsForRenderView(0, 2);
+  host_.BlockRequestsForRenderView(0, 3);
+
+  MakeTestRequest(0, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 1, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(0, 1, 4, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 2, 5, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 3, 6, URLRequestTestJob::test_url_3());
+
+  // Flush all the pending requests
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+
+  // Sort out all the messages we saw by request
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  // All requests but the 2 for the RVH 0 should have been blocked.
+  ASSERT_EQ(2, msgs.size());
+
+  CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
+  CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_3());
+
+  // Resume requests for RVH 1 and flush pending requests.
+  host_.ResumeBlockedRequestsForRenderView(0, 1);
+  KickOffRequest();
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+
+  msgs.clear();
+  accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(2, msgs.size());
+  CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_2());
+  CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_1());
+
+  // Test that new requests are not blocked for RVH 1.
+  MakeTestRequest(0, 1, 7, URLRequestTestJob::test_url_1());
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+  msgs.clear();
+  accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(1, msgs.size());
+  CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
+
+  // Now resumes requests for all RVH (2 and 3).
+  host_.ResumeBlockedRequestsForRenderView(0, 2);
+  host_.ResumeBlockedRequestsForRenderView(0, 3);
+  KickOffRequest();
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+
+  msgs.clear();
+  accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(2, msgs.size());
+  CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_2());
+  CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_3());
+}
+
+// Tests blocking and canceling requests.
+TEST_F(ResourceDispatcherHostTest, TestBlockingCancelingRequests) {
+  host_.BlockRequestsForRenderView(0, 1);
+
+  MakeTestRequest(0, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 1, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(0, 1, 4, URLRequestTestJob::test_url_1());
+
+  // Flush all the pending requests.
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+
+  // Sort out all the messages we saw by request.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  // The 2 requests for the RVH 0 should have been processed.
+  ASSERT_EQ(2, msgs.size());
+
+  CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
+  CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_3());
+
+  // Cancel requests for RVH 1.
+  host_.CancelBlockedRequestsForRenderView(0, 1);
+  KickOffRequest();
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+  msgs.clear();
+  accum_.GetClassifiedMessages(&msgs);
+  ASSERT_EQ(0, msgs.size());
+}
+
+// Tests that blocked requests are canceled if their associated process dies.
+TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) {
+  host_.BlockRequestsForRenderView(1, 0);
+
+  MakeTestRequest(0, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(1, 0, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(1, 0, 4, URLRequestTestJob::test_url_1());
+
+  // Simulate process death.
+  host_.CancelRequestsForProcess(1);
+
+  // Flush all the pending requests.
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+
+  // Sort out all the messages we saw by request.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  // The 2 requests for the RVH 0 should have been processed.
+  ASSERT_EQ(2, msgs.size());
+
+  CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
+  CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_3());
+
+  EXPECT_TRUE(host_.blocked_requests_map_.empty());
+}
+
+// Tests that blocked requests don't leak when the ResourceDispatcherHost goes
+// away.  Note that we rely on Purify for finding the leaks if any.
+// If this test turns the Purify bot red, check the ResourceDispatcherHost
+// destructor to make sure the blocked requests are deleted.
+TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsDontLeak) {
+  host_.BlockRequestsForRenderView(0, 1);
+  host_.BlockRequestsForRenderView(0, 2);
+  host_.BlockRequestsForRenderView(1, 1);
+
+  MakeTestRequest(0, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 1, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(1, 1, 4, URLRequestTestJob::test_url_1());
+  MakeTestRequest(0, 2, 5, URLRequestTestJob::test_url_2());
+  MakeTestRequest(0, 2, 6, URLRequestTestJob::test_url_3());
+
+  // Flush all the pending requests.
+  while (URLRequestTestJob::ProcessOnePendingMessage());
+}