Create a ResourceMessageFilter to filter resource related IPCs. This gets ri...

chrome/browser/renderer_host/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2010 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/file_path.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "chrome/browser/renderer_host/resource_handler.h"
+#include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_test_job.h"
@@ skipping 95 matching lines @@
         messages_.erase(messages_.begin() + i);
         i--;
       }
     }
     messages_.erase(messages_.begin());
     msgs->push_back(cur_requests);
   }
 }
 
 // This class forwards the incoming messages to the ResourceDispatcherHostTest.
-// This is used to emulate different sub-procseses, since this receiver will
+// This is used to emulate different sub-processes, since this filter will
 // have a different ID than the original. For the test, we want all the incoming
 // messages to go to the same place, which is why this forwards.
-class ForwardingReceiver : public ResourceDispatcherHost::Receiver {
+class ForwardingFilter : public ResourceMessageFilter {
  public:
-  explicit ForwardingReceiver(ResourceDispatcherHost::Receiver* dest)
-    : ResourceDispatcherHost::Receiver(dest->type(), -1),
+  explicit ForwardingFilter(IPC::Message::Sender* dest)
+    : ResourceMessageFilter(ChildProcessInfo::GenerateChildProcessUniqueId(),
+                            ChildProcessInfo::RENDER_PROCESS,
+                            NULL),
       dest_(dest) {
-    set_handle(dest->handle());
+    OnChannelConnected(base::GetCurrentProcId());
   }
 
-  // ResourceDispatcherHost::Receiver implementation
+  // ResourceMessageFilter override
   virtual bool Send(IPC::Message* msg) {
+    if (!dest_)
+      return false;
     return dest_->Send(msg);
   }
-  URLRequestContext* GetRequestContext(
-      uint32 request_id,
-      const ViewHostMsg_Resource_Request& request_data) {
-    return dest_->GetRequestContext(request_id, request_data);
-  }
 
  private:
-  ResourceDispatcherHost::Receiver* dest_;
+  IPC::Message::Sender* dest_;
 
-  DISALLOW_COPY_AND_ASSIGN(ForwardingReceiver);
+  DISALLOW_COPY_AND_ASSIGN(ForwardingFilter);
 };
 
 class ResourceDispatcherHostTest : public testing::Test,
-                                   public ResourceDispatcherHost::Receiver {
+                                   public IPC::Message::Sender {
  public:
   ResourceDispatcherHostTest()
-      : Receiver(ChildProcessInfo::RENDER_PROCESS, -1),
+      : ALLOW_THIS_IN_INITIALIZER_LIST(filter_(new ForwardingFilter(this))),
         ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         old_factory_(NULL),
         resource_type_(ResourceType::SUB_RESOURCE) {
-    set_handle(base::GetCurrentProcessHandle());
   }
-  // ResourceDispatcherHost::Receiver implementation
+  // IPC::Message::Sender implementation
   virtual bool Send(IPC::Message* msg) {
     accum_.AddMessage(*msg);
     delete msg;
     return true;
   }
 
-  URLRequestContext* GetRequestContext(
-      uint32 request_id,
-      const ViewHostMsg_Resource_Request& request_data) {
-    return NULL;
-  }
-
  protected:
   // testing::Test
   virtual void SetUp() {
     DCHECK(!test_fixture_);
     test_fixture_ = this;
     ChildProcessSecurityPolicy::GetInstance()->Add(0);
     net::URLRequest::RegisterProtocolFactory(
         "test",
         &ResourceDispatcherHostTest::Factory);
     EnsureTestSchemeIsAllowed();
@@ skipping 12 matching lines @@
     ChildProcessSecurityPolicy::GetInstance()->Remove(0);
 
     // The plugin lib is automatically loaded during these test
     // and we want a clean environment for other tests.
     ChromePluginLib::UnloadAllPlugins();
 
     // Flush the message loop to make Purify happy.
     message_loop_.RunAllPending();
   }
 
-  // Creates a request using the current test object as the receiver.
+  // Creates a request using the current test object as the filter.
   void MakeTestRequest(int render_view_id,
                        int request_id,
                        const GURL& url);
 
-  // Generates a request using the given receiver. This will probably be a
-  // ForwardingReceiver.
-  void MakeTestRequest(ResourceDispatcherHost::Receiver* receiver,
+  // Generates a request using the given filter. This will probably be a
+  // ForwardingFilter.
+  void MakeTestRequest(ResourceMessageFilter* filter,
                        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) {
@@ skipping 28 matching lines @@
   static net::URLRequestJob* Factory(net::URLRequest* request,
                                      const std::string& scheme) {
     if (test_fixture_->response_headers_.empty()) {
       return new URLRequestTestJob(request);
     } else {
       return new URLRequestTestJob(request, test_fixture_->response_headers_,
                                    test_fixture_->response_data_, false);
     }
   }
 
+  scoped_refptr<ForwardingFilter> filter_;
   MessageLoopForIO message_loop_;
   BrowserThread ui_thread_;
   BrowserThread io_thread_;
   ResourceDispatcherHost host_;
   ResourceIPCAccumulator accum_;
   std::string response_headers_;
   std::string response_data_;
   std::string scheme_;
   net::URLRequest::ProtocolFactory* old_factory_;
   ResourceType::Type resource_type_;
   static ResourceDispatcherHostTest* test_fixture_;
 };
 // Static.
 ResourceDispatcherHostTest* ResourceDispatcherHostTest::test_fixture_ = NULL;
 
 void ResourceDispatcherHostTest::MakeTestRequest(int render_view_id,
                                                  int request_id,
                                                  const GURL& url) {
-  MakeTestRequest(this, render_view_id, request_id, url);
+  MakeTestRequest(filter_.get(), render_view_id, request_id, url);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequest(
-    ResourceDispatcherHost::Receiver* receiver,
+    ResourceMessageFilter* filter,
     int render_view_id,
     int request_id,
     const GURL& url) {
   ViewHostMsg_Resource_Request request =
       CreateResourceRequest("GET", resource_type_, url);
   ViewHostMsg_RequestResource msg(render_view_id, request_id, request);
   bool msg_was_ok;
-  host_.OnMessageReceived(msg, receiver, &msg_was_ok);
+  host_.OnMessageReceived(msg, filter, &msg_was_ok);
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::MakeCancelRequest(int request_id) {
-  host_.CancelRequest(id(), request_id, false);
+  host_.CancelRequest(filter_->child_id(), request_id, false);
 }
 
 void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages,
                             const std::string& reference_data) {
   // A successful request will have received 4 messages:
   //     ReceivedResponse    (indicates headers received)
   //     DataReceived        (data)
   //    XXX DataReceived        (0 bytes remaining from a read)
   //     RequestComplete     (request is done)
   //
@@ skipping 87 matching lines @@
   int request_id;
   URLRequestStatus status;
 
   void* iter = NULL;
   ASSERT_TRUE(IPC::ReadParam(&msgs[1][1], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&msgs[1][1], &iter, &status));
 
   EXPECT_EQ(URLRequestStatus::CANCELED, status.status());
 }
 
+// the host delegate acts as a second one so we can have some requests

[brettw, 2010/12/15 21:31:10]

Style nit: can you capitalize this?

[jam, 2010/12/15 21:41:04]

Done.

+// pending and some canceled
+class TestFilter : public ForwardingFilter {
+ public:
+  TestFilter()
+      : ForwardingFilter(NULL),
+        has_canceled_(false), received_after_canceled_(0) {

[brettw, 2010/12/15 21:31:10]

Style nit: can you move the last initializer to its own line?

[jam, 2010/12/15 21:41:04]

Done.

+  }
+
+  // ForwardingFilter override
+  virtual bool Send(IPC::Message* msg) {
+    // no messages should be received when the process has been canceled
+    if (has_canceled_)
+      received_after_canceled_++;
+    delete msg;
+    return true;
+  }
+  bool has_canceled_;
+  int received_after_canceled_;
+};
+
 // Tests CancelRequestsForProcess
 TEST_F(ResourceDispatcherHostTest, TestProcessCancel) {
-  // the host delegate acts as a second one so we can have some requests
-  // pending and some canceled
-  class TestReceiver : public ResourceDispatcherHost::Receiver {
-   public:
-    TestReceiver()
-        : Receiver(ChildProcessInfo::RENDER_PROCESS, -1),
-          has_canceled_(false),
-          received_after_canceled_(0) {
-    }
-
-    // ResourceDispatcherHost::Receiver implementation
-    virtual bool Send(IPC::Message* msg) {
-      // no messages should be received when the process has been canceled
-      if (has_canceled_)
-        received_after_canceled_++;
-      delete msg;
-      return true;
-    }
-    URLRequestContext* GetRequestContext(
-        uint32 request_id,
-        const ViewHostMsg_Resource_Request& request_data) {
-      return NULL;
-    }
-    bool has_canceled_;
-    int received_after_canceled_;
-  };
-  TestReceiver test_receiver;
+  scoped_refptr<TestFilter> test_filter = new TestFilter();
 
   // request 1 goes to the test delegate
   ViewHostMsg_Resource_Request request = CreateResourceRequest(
       "GET", ResourceType::SUB_RESOURCE, URLRequestTestJob::test_url_1());
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  MakeTestRequest(&test_receiver, 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(test_filter.get(), 0, 1, URLRequestTestJob::test_url_1());
 
   // request 2 goes to us
   MakeTestRequest(0, 2, URLRequestTestJob::test_url_2());
 
   // request 3 goes to the test delegate
-  MakeTestRequest(&test_receiver, 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(test_filter.get(), 0, 3, URLRequestTestJob::test_url_3());
 
   // 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
   // breaks the whole test.
   //EXPECT_EQ(3, host_.pending_requests());
 
   // Process each request for one level so one callback is called.
   for (int i = 0; i < 3; i++)
     EXPECT_TRUE(URLRequestTestJob::ProcessOnePendingMessage());
 
   // Cancel the requests to the test process.
-  host_.CancelRequestsForProcess(id());
-  test_receiver.has_canceled_ = true;
+  host_.CancelRequestsForProcess(filter_->child_id());
+  test_filter->has_canceled_ = true;
 
   // Flush all the pending requests.
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.pending_requests());
-  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(
-      id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
   // The test delegate should not have gotten any messages after being canceled.
-  ASSERT_EQ(0, test_receiver.received_after_canceled_);
+  ASSERT_EQ(0, test_filter->received_after_canceled_);
 
   // We should have gotten exactly one result.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_2());
 }
 
 // Tests blocking and resuming requests.
 TEST_F(ResourceDispatcherHostTest, TestBlockingResumingRequests) {
-  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(
-      id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
-  host_.BlockRequestsForRoute(id(), 1);
-  host_.BlockRequestsForRoute(id(), 2);
-  host_.BlockRequestsForRoute(id(), 3);
+  host_.BlockRequestsForRoute(filter_->child_id(), 1);
+  host_.BlockRequestsForRoute(filter_->child_id(), 2);
+  host_.BlockRequestsForRoute(filter_->child_id(), 3);
 
   MakeTestRequest(0, 1, URLRequestTestJob::test_url_1());
   MakeTestRequest(1, 2, URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, URLRequestTestJob::test_url_3());
   MakeTestRequest(1, 4, URLRequestTestJob::test_url_1());
   MakeTestRequest(2, 5, URLRequestTestJob::test_url_2());
   MakeTestRequest(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(2U, 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_.ResumeBlockedRequestsForRoute(id(), 1);
+  host_.ResumeBlockedRequestsForRoute(filter_->child_id(), 1);
   KickOffRequest();
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(2U, 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(1, 7, URLRequestTestJob::test_url_1());
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
 
   // Now resumes requests for all RVH (2 and 3).
-  host_.ResumeBlockedRequestsForRoute(id(), 2);
-  host_.ResumeBlockedRequestsForRoute(id(), 3);
+  host_.ResumeBlockedRequestsForRoute(filter_->child_id(), 2);
+  host_.ResumeBlockedRequestsForRoute(filter_->child_id(), 3);
   KickOffRequest();
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
 
-  EXPECT_EQ(0,
-            host_.GetOutstandingRequestsMemoryCost(id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(2U, 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) {
-  EXPECT_EQ(0,
-            host_.GetOutstandingRequestsMemoryCost(id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
-  host_.BlockRequestsForRoute(id(), 1);
+  host_.BlockRequestsForRoute(filter_->child_id(), 1);
 
   MakeTestRequest(0, 1, URLRequestTestJob::test_url_1());
   MakeTestRequest(1, 2, URLRequestTestJob::test_url_2());
   MakeTestRequest(0, 3, URLRequestTestJob::test_url_3());
   MakeTestRequest(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(2U, msgs.size());
 
   CheckSuccessfulRequest(msgs[0], URLRequestTestJob::test_data_1());
   CheckSuccessfulRequest(msgs[1], URLRequestTestJob::test_data_3());
 
   // Cancel requests for RVH 1.
-  host_.CancelBlockedRequestsForRoute(id(), 1);
+  host_.CancelBlockedRequestsForRoute(filter_->child_id(), 1);
   KickOffRequest();
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
 
-  EXPECT_EQ(0,
-            host_.GetOutstandingRequestsMemoryCost(id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
   msgs.clear();
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(0U, msgs.size());
 }
 
 // Tests that blocked requests are canceled if their associated process dies.
 TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) {
-  // This second receiver is used to emulate a second process.
-  ForwardingReceiver second_receiver(this);
+  // This second filter is used to emulate a second process.
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(this);
 
-  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(
-      id()));
-  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(
-      second_receiver.id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
+  EXPECT_EQ(0,
+            host_.GetOutstandingRequestsMemoryCost(second_filter->child_id()));
 
-  host_.BlockRequestsForRoute(second_receiver.id(), 0);
+  host_.BlockRequestsForRoute(second_filter->child_id(), 0);
 
-  MakeTestRequest(this, 0, 1, URLRequestTestJob::test_url_1());
-  MakeTestRequest(&second_receiver, 0, 2, URLRequestTestJob::test_url_2());
-  MakeTestRequest(this, 0, 3, URLRequestTestJob::test_url_3());
-  MakeTestRequest(&second_receiver, 0, 4, URLRequestTestJob::test_url_1());
+  MakeTestRequest(filter_.get(), 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(second_filter.get(), 0, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(filter_.get(), 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(second_filter.get(), 0, 4, URLRequestTestJob::test_url_1());
 
   // Simulate process death.
-  host_.CancelRequestsForProcess(second_receiver.id());
+  host_.CancelRequestsForProcess(second_filter->child_id());
 
   // Flush all the pending requests.
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
 
-  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(
-      id()));
-  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(
-      second_receiver.id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
+  EXPECT_EQ(0,
+            host_.GetOutstandingRequestsMemoryCost(second_filter->child_id()));
 
   // 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(2U, 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) {
-  // This second receiver is used to emulate a second process.
-  ForwardingReceiver second_receiver(this);
+  // This second filter is used to emulate a second process.
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(this);
 
-  host_.BlockRequestsForRoute(id(), 1);
-  host_.BlockRequestsForRoute(id(), 2);
-  host_.BlockRequestsForRoute(second_receiver.id(), 1);
+  host_.BlockRequestsForRoute(filter_->child_id(), 1);
+  host_.BlockRequestsForRoute(filter_->child_id(), 2);
+  host_.BlockRequestsForRoute(second_filter->child_id(), 1);
 
-  MakeTestRequest(this, 0, 1, URLRequestTestJob::test_url_1());
-  MakeTestRequest(this, 1, 2, URLRequestTestJob::test_url_2());
-  MakeTestRequest(this, 0, 3, URLRequestTestJob::test_url_3());
-  MakeTestRequest(&second_receiver, 1, 4, URLRequestTestJob::test_url_1());
-  MakeTestRequest(this, 2, 5, URLRequestTestJob::test_url_2());
-  MakeTestRequest(this, 2, 6, URLRequestTestJob::test_url_3());
+  MakeTestRequest(filter_.get(), 0, 1, URLRequestTestJob::test_url_1());
+  MakeTestRequest(filter_.get(), 1, 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(filter_.get(), 0, 3, URLRequestTestJob::test_url_3());
+  MakeTestRequest(second_filter.get(), 1, 4, URLRequestTestJob::test_url_1());
+  MakeTestRequest(filter_.get(), 2, 5, URLRequestTestJob::test_url_2());
+  MakeTestRequest(filter_.get(), 2, 6, URLRequestTestJob::test_url_3());
 
   // Flush all the pending requests.
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
 }
 
 // Test the private helper method "CalculateApproximateMemoryCost()".
 TEST_F(ResourceDispatcherHostTest, CalculateApproximateMemoryCost) {
   net::URLRequest req(GURL("http://www.google.com"), NULL);
   EXPECT_EQ(4427, ResourceDispatcherHost::CalculateApproximateMemoryCost(&req));
 
@@ skipping 44 matching lines @@
   // When an entry reaches 0, it should be deleted.
   EXPECT_TRUE(host_.outstanding_requests_memory_cost_map_.end() ==
       host_.outstanding_requests_memory_cost_map_.find(7));
   EXPECT_TRUE(host_.outstanding_requests_memory_cost_map_.end() ==
       host_.outstanding_requests_memory_cost_map_.find(3));
 }
 
 // Test that when too many requests are outstanding for a particular
 // render_process_host_id, any subsequent request from it fails.
 TEST_F(ResourceDispatcherHostTest, TooManyOutstandingRequests) {
-  EXPECT_EQ(0,
-            host_.GetOutstandingRequestsMemoryCost(id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
   // Expected cost of each request as measured by
   // ResourceDispatcherHost::CalculateApproximateMemoryCost().
   int kMemoryCostOfTest2Req =
       ResourceDispatcherHost::kAvgBytesPerOutstandingRequest +
       std::string("GET").size() +
       URLRequestTestJob::test_url_2().spec().size();
 
   // Tighten the bound on the ResourceDispatcherHost, to speed things up.
   int kMaxCostPerProcess = 440000;
   host_.set_max_outstanding_requests_cost_per_process(kMaxCostPerProcess);
 
   // Determine how many instance of test_url_2() we can request before
   // throttling kicks in.
   size_t kMaxRequests = kMaxCostPerProcess / kMemoryCostOfTest2Req;
 
-  // This second receiver is used to emulate a second process.
-  ForwardingReceiver second_receiver(this);
+  // This second filter is used to emulate a second process.
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(this);
 
   // Saturate the number of outstanding requests for our process.
   for (size_t i = 0; i < kMaxRequests; ++i)
-    MakeTestRequest(this, 0, i + 1, URLRequestTestJob::test_url_2());
+    MakeTestRequest(filter_.get(), 0, i + 1, URLRequestTestJob::test_url_2());
 
   // Issue two more requests for our process -- these should fail immediately.
-  MakeTestRequest(this, 0, kMaxRequests + 1, URLRequestTestJob::test_url_2());
-  MakeTestRequest(this, 0, kMaxRequests + 2, URLRequestTestJob::test_url_2());
+  MakeTestRequest(filter_.get(), 0, kMaxRequests + 1,
+                  URLRequestTestJob::test_url_2());
+  MakeTestRequest(filter_.get(), 0, kMaxRequests + 2,
+                  URLRequestTestJob::test_url_2());
 
   // Issue two requests for the second process -- these should succeed since
   // it is just process 0 that is saturated.
-  MakeTestRequest(&second_receiver, 0, kMaxRequests + 3,
+  MakeTestRequest(second_filter.get(), 0, kMaxRequests + 3,
                   URLRequestTestJob::test_url_2());
-  MakeTestRequest(&second_receiver, 0, kMaxRequests + 4,
+  MakeTestRequest(second_filter.get(), 0, kMaxRequests + 4,
                   URLRequestTestJob::test_url_2());
 
   // Flush all the pending requests.
   while (URLRequestTestJob::ProcessOnePendingMessage()) {}
   MessageLoop::current()->RunAllPending();
 
-  EXPECT_EQ(0,
-            host_.GetOutstandingRequestsMemoryCost(id()));
+  EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(filter_->child_id()));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
 
   // We issued (kMaxRequests + 4) total requests.
   ASSERT_EQ(kMaxRequests + 4, msgs.size());
 
   // Check that the first kMaxRequests succeeded.
   for (size_t i = 0; i < kMaxRequests; ++i)
@@ skipping 263 matching lines @@
   EXPECT_TRUE(request_info_->replace_extension_localization_templates());
 }
 
 TEST_F(ApplyExtensionLocalizationFilterTest, GoodSchemeWrongResourceType) {
   resource_type_ = ResourceType::MAIN_FRAME;
   ResourceDispatcherHost::ApplyExtensionLocalizationFilter(*url_,
       resource_type_, request_info_.get());
 
   EXPECT_FALSE(request_info_->replace_extension_localization_templates());
 }