Cleanup channel dispatchers

remoting/protocol/message_reader.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 "remoting/protocol/message_reader.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
@@ skipping 11 matching lines @@
 static const int kReadBufferSize = 4096;
 
 MessageReader::MessageReader()
     : socket_(nullptr),
       read_pending_(false),
       pending_messages_(0),
       closed_(false),
       weak_factory_(this) {
 }
 
-void MessageReader::Init(net::Socket* socket,
-                         const MessageReceivedCallback& callback) {
+MessageReader::~MessageReader() {
+}
+
+void MessageReader::SetMessageReceivedCallback(
+    const MessageReceivedCallback& callback) {
   DCHECK(CalledOnValidThread());
   message_received_callback_ = callback;
+}
+
+void MessageReader::StartReading(net::Socket* socket) {
+  DCHECK(CalledOnValidThread());
   DCHECK(socket);
   socket_ = socket;
   DoRead();
 }
 
-MessageReader::~MessageReader() {
-}
-
 void MessageReader::DoRead() {
   DCHECK(CalledOnValidThread());
   // 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);
     int result = socket_->Read(
         read_buffer_.get(),
         kReadBufferSize,
         base::Bind(&MessageReader::OnRead, weak_factory_.GetWeakPtr()));
@@ skipping 43 matching lines @@
     pending_messages_++;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&MessageReader::RunCallback,
                    weak_factory_.GetWeakPtr(),
                    base::Passed(make_scoped_ptr(buffer))));
   }
 }
 
 void MessageReader::RunCallback(scoped_ptr<CompoundBuffer> message) {
-  message_received_callback_.Run(
-      message.Pass(), base::Bind(&MessageReader::OnMessageDone,
-                                 weak_factory_.GetWeakPtr()));
+  if (!message_received_callback_.is_null()){
+    message_received_callback_.Run(
+        message.Pass(),
+        base::Bind(&MessageReader::OnMessageDone, weak_factory_.GetWeakPtr()));
+  }
 }
 
 void MessageReader::OnMessageDone() {
   DCHECK(CalledOnValidThread());
   pending_messages_--;
   DCHECK_GE(pending_messages_, 0);
 
   // Start next read if necessary.
   DoRead();
 }
 
 }  // namespace protocol
 }  // namespace remoting