Switch remoting/protocol to new callbacks

remoting/protocol/message_reader.cc

 // Copyright (c) 2011 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 "remoting/protocol/message_reader.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "net/base/io_buffer.h"
@@ skipping 14 matching lines @@
       closed_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &MessageReader::OnRead)) {
 }
 
 MessageReader::~MessageReader() {
   CHECK_EQ(pending_messages_, 0);
 }
 
 void MessageReader::Init(net::Socket* socket,
-                         MessageReceivedCallback* callback) {
-  message_received_callback_.reset(callback);
+                         const MessageReceivedCallback& callback) {
+  message_received_callback_ = callback;
   DCHECK(socket);
   socket_ = socket;
   DoRead();
 }
 
 void MessageReader::DoRead() {
   // Don't try to read again if there is another read pending or we
   // have messages that we haven't finished processing yet.
   while (!closed_ && !read_pending_ && pending_messages_ == 0) {
     read_buffer_ = new net::IOBuffer(kReadBufferSize);
@@ skipping 42 matching lines @@
       break;
     new_messages.push_back(buffer);
   }
 
   pending_messages_ += new_messages.size();
 
   // TODO(lambroslambrou): MessageLoopProxy::current() will not work from the
   // plugin thread if this code is compiled into a separate binary.  Fix this.
   for (std::vector<CompoundBuffer*>::iterator it = new_messages.begin();
        it != new_messages.end(); ++it) {
-    message_received_callback_->Run(*it, NewRunnableMethod(
-        this, &MessageReader::OnMessageDone, *it,
-        base::MessageLoopProxy::current()));
+    message_received_callback_.Run(*it, base::Bind(
+        &MessageReader::OnMessageDone, this,
+        *it, base::MessageLoopProxy::current()));
   }
 }
 
 void MessageReader::OnMessageDone(
     CompoundBuffer* message,
     scoped_refptr<base::MessageLoopProxy> message_loop) {
   if (!message_loop->BelongsToCurrentThread()) {
     message_loop->PostTask(
         FROM_HERE,
         base::Bind(&MessageReader::OnMessageDone, this, message, message_loop));
     return;
   }
   delete message;
   ProcessDoneEvent();
 }
 
 void MessageReader::ProcessDoneEvent() {
   pending_messages_--;
   DCHECK_GE(pending_messages_, 0);
 
   DoRead(); // Start next read if neccessary.
 }
 
 }  // namespace protocol
 }  // namespace remoting