Decouple IPC::MessageFilter from IPC::Channel

content/browser/loader/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2012 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/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "content/browser/browser_message_filter_peer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_loader.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/child_process_host_impl.h"
@@ skipping 181 matching lines @@
 // have a different ID than the original.
 class TestFilter : public ResourceMessageFilter {
  public:
   explicit TestFilter(ResourceContext* resource_context)
       : ResourceMessageFilter(
             ChildProcessHostImpl::GenerateChildProcessUniqueId(),
             PROCESS_TYPE_RENDERER, NULL, NULL, NULL, NULL,
             base::Bind(&TestFilter::GetContexts, base::Unretained(this))),
         resource_context_(resource_context),
         canceled_(false),
-        received_after_canceled_(0) {
+        received_after_canceled_(0),
+        peer_(new BrowserMessageFilterPeer(base::GetCurrentProcId())) {
     ChildProcessSecurityPolicyImpl::GetInstance()->Add(child_id());
-    set_peer_pid_for_testing(base::GetCurrentProcId());
+    OnFilterAddedToHost(peer_.get());
   }
 
   void set_canceled(bool canceled) { canceled_ = canceled; }
   int received_after_canceled() const { return received_after_canceled_; }
 
   // ResourceMessageFilter override
   virtual bool Send(IPC::Message* msg) OVERRIDE {
     // No messages should be received when the process has been canceled.
     if (canceled_)
       received_after_canceled_++;
@@ skipping 11 matching lines @@
   void GetContexts(const ResourceHostMsg_Request& request,
                    ResourceContext** resource_context,
                    net::URLRequestContext** request_context) {
     *resource_context = resource_context_;
     *request_context = resource_context_->GetRequestContext();
   }
 
   ResourceContext* resource_context_;
   bool canceled_;
   int received_after_canceled_;
-
+  scoped_ptr<BrowserMessageFilterPeer> peer_;
   DISALLOW_COPY_AND_ASSIGN(TestFilter);
 };
 
 
 // This class forwards the incoming messages to the ResourceDispatcherHostTest.
 // For the test, we want all the incoming messages to go to the same place,
 // which is why this forwards.
 class ForwardingFilter : public TestFilter {
  public:
   explicit ForwardingFilter(IPC::Sender* dest,
@@ skipping 915 matching lines @@
   host_.OnMessageReceived(msg_ping, filter_);
 
   // Remove the filter before processing the requests by simulating channel
   // closure.
   ResourceRequestInfoImpl* info_prefetch = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(GlobalRequestID(filter_->child_id(), 1)));
   ResourceRequestInfoImpl* info_ping = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(GlobalRequestID(filter_->child_id(), 2)));
   DCHECK_EQ(filter_.get(), info_prefetch->filter());
   DCHECK_EQ(filter_.get(), info_ping->filter());
-  filter_->OnChannelClosing();
+  filter_->OnSenderClosing();
   info_prefetch->filter_.reset();
   info_ping->filter_.reset();
 
   // From the renderer's perspective, the requests were cancelled.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(2U, msgs.size());
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
   CheckRequestCompleteErrorCode(msgs[1][0], net::ERR_ABORTED);
 
@@ skipping 24 matching lines @@
       net::URLRequestTestJob::test_url_redirect_to_url_2());
 
   ResourceHostMsg_RequestResource msg(0, 1, request);
   host_.OnMessageReceived(msg, filter_);
 
   // Remove the filter before processing the request by simulating channel
   // closure.
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
-  info->filter_->OnChannelClosing();
+  info->filter_->OnSenderClosing();
   info->filter_.reset();
 
   // From the renderer's perspective, the request was cancelled.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
   CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED);
 
   // But it continues detached.
   EXPECT_EQ(1, host_.pending_requests());
@@ skipping 1555 matching lines @@
 
   // Register it for a resource request.
   host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path);
   deletable_file = NULL;
 
   // Should be readable now.
   EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
 
   // Let the process die.
-  filter_->OnChannelClosing();
+  filter_->OnSenderClosing();
   base::RunLoop().RunUntilIdle();
 
   // The file is no longer readable to the child and has been deleted.
   EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile(
       filter_->child_id(), file_path));
   EXPECT_FALSE(base::PathExists(file_path));
 }
 
 TEST_F(ResourceDispatcherHostTest, DownloadToFile) {
   // Make a request which downloads to file.
@@ skipping 100 matching lines @@
     } else {
       return new net::URLRequestTestJob(
           request, network_delegate,
           test_fixture_->response_headers_, test_fixture_->response_data_,
           false);
     }
   }
 }
 
 }  // namespace content