Manual fixups for scoped_refptr operator T* removal in ipc/

ipc/ipc_channel_proxy.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 "ipc/ipc_channel_proxy.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "ipc/ipc_channel_factory.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/message_filter.h"
 #include "ipc/message_filter_router.h"
 
 namespace IPC {
 
 //------------------------------------------------------------------------------
 
-ChannelProxy::Context::Context(Listener* listener,
-                               base::SingleThreadTaskRunner* ipc_task_runner)
+ChannelProxy::Context::Context(
+    Listener* listener,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner)
     : listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       listener_(listener),
       ipc_task_runner_(ipc_task_runner),
       channel_connected_called_(false),
       message_filter_router_(new MessageFilterRouter()),
       peer_pid_(base::kNullProcessId) {
   DCHECK(ipc_task_runner_.get());
   // The Listener thread where Messages are handled must be a separate thread
   // to avoid oversubscribing the IO thread. If you trigger this error, you
   // need to either:
@@ skipping 265 matching lines @@
     listener_->OnBadMessageReceived(message);
 }
 
 //-----------------------------------------------------------------------------
 
 // static
 scoped_ptr<ChannelProxy> ChannelProxy::Create(
     const IPC::ChannelHandle& channel_handle,
     Channel::Mode mode,
     Listener* listener,
-    base::SingleThreadTaskRunner* ipc_task_runner) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   scoped_ptr<ChannelProxy> channel(new ChannelProxy(listener, ipc_task_runner));
   channel->Init(channel_handle, mode, true);
   return channel.Pass();
 }
 
 // static
 scoped_ptr<ChannelProxy> ChannelProxy::Create(
     scoped_ptr<ChannelFactory> factory,
     Listener* listener,
-    base::SingleThreadTaskRunner* ipc_task_runner) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   scoped_ptr<ChannelProxy> channel(new ChannelProxy(listener, ipc_task_runner));
   channel->Init(factory.Pass(), true);
   return channel.Pass();
 }
 
 ChannelProxy::ChannelProxy(Context* context)
     : context_(context),
       did_init_(false) {
 }
 
-ChannelProxy::ChannelProxy(Listener* listener,
-                           base::SingleThreadTaskRunner* ipc_task_runner)
+ChannelProxy::ChannelProxy(
+    Listener* listener,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner)
     : context_(new Context(listener, ipc_task_runner)), did_init_(false) {
 }
 
 ChannelProxy::~ChannelProxy() {
   DCHECK(CalledOnValidThread());
 
   Close();
 }
 
 void ChannelProxy::Init(const IPC::ChannelHandle& channel_handle,
@@ skipping 105 matching lines @@
   Channel* channel = context_.get()->channel_.get();
   // Channel must have been created first.
   DCHECK(channel) << context_.get()->channel_id_;
   return channel->TakeClientFileDescriptor();
 }
 #endif
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC