Use IPC::Sender and IPC::Listener in content.

content/browser/renderer_host/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 "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 143 matching lines @@
  private:
   net::URLRequestContext* const request_context_;
 };
 
 // This class forwards the incoming messages to the ResourceDispatcherHostTest.
 // 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 ForwardingFilter : public ResourceMessageFilter {
  public:
-  explicit ForwardingFilter(IPC::Message::Sender* dest,
+  explicit ForwardingFilter(IPC::Sender* dest,
                             content::ResourceContext* resource_context)
     : ResourceMessageFilter(
         ChildProcessHostImpl::GenerateChildProcessUniqueId(),
         content::PROCESS_TYPE_RENDERER,
         resource_context,
         new MockURLRequestContextSelector(
             resource_context->GetRequestContext())),
       dest_(dest) {
     OnChannelConnected(base::GetCurrentProcId());
   }
 
   // ResourceMessageFilter override
   virtual bool Send(IPC::Message* msg) {
     if (!dest_)
       return false;
     return dest_->Send(msg);
   }
 
  protected:
   virtual ~ForwardingFilter() {}
 
  private:
-  IPC::Message::Sender* dest_;
+  IPC::Sender* dest_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingFilter);
 };
 
 // This class is a variation on URLRequestTestJob in that it does
 // not complete start upon entry, only when specifically told to.
 class URLRequestTestDelayedStartJob : public net::URLRequestTestJob {
  public:
   URLRequestTestDelayedStartJob(net::URLRequest* request)
       : net::URLRequestTestJob(request) {
@@ skipping 166 matching lines @@
     if (defer_flags_ != DEFER_NONE)
       throttles->push_back(new GenericResourceThrottle(defer_flags_));
   }
 
  private:
   int defer_flags_;
   scoped_ptr<base::SupportsUserData::Data> user_data_;
 };
 
 class ResourceDispatcherHostTest : public testing::Test,
-                                   public IPC::Message::Sender {
+                                   public IPC::Sender {
  public:
   ResourceDispatcherHostTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE_USER_BLOCKING, &message_loop_),
         cache_thread_(BrowserThread::CACHE, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         old_factory_(NULL),
         resource_type_(ResourceType::SUB_RESOURCE) {
     browser_context_.reset(new content::TestBrowserContext());
     BrowserContext::EnsureResourceContextInitialized(browser_context_.get());
     message_loop_.RunAllPending();
     filter_ = new ForwardingFilter(
         this, browser_context_->GetResourceContext());
   }
-  // IPC::Message::Sender implementation
+  // IPC::Sender implementation
   virtual bool Send(IPC::Message* msg) {
     accum_.AddMessage(*msg);
     delete msg;
     return true;
   }
 
  protected:
   // testing::Test
   virtual void SetUp() {
     DCHECK(!test_fixture_);
@@ skipping 1028 matching lines @@
   PickleIterator iter(msgs[0][0]);
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &status));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(net::URLRequestStatus::FAILED, status.status());
   EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME, status.error());
 }
 
 }  // namespace content