Cleanup channel dispatchers

remoting/protocol/channel_multiplexer.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/channel_multiplexer.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 330 matching lines @@
     std::swap(cb, read_callback_);
     cb.Run(result);
   }
 }
 
 ChannelMultiplexer::ChannelMultiplexer(StreamChannelFactory* factory,
                                        const std::string& base_channel_name)
     : base_channel_factory_(factory),
       base_channel_name_(base_channel_name),
       next_channel_id_(0),
+      parser_(base::Bind(&ChannelMultiplexer::OnIncomingPacket,
+                         base::Unretained(this)),
+              &reader_),
       weak_factory_(this) {
 }
 
 ChannelMultiplexer::~ChannelMultiplexer() {
   DCHECK(pending_channels_.empty());
   STLDeleteValues(&channels_);
 
   // Cancel creation of the base channel if it hasn't finished.
   if (base_channel_factory_)
     base_channel_factory_->CancelChannelCreation(base_channel_name_);
@@ skipping 32 matching lines @@
   }
 }
 
 void ChannelMultiplexer::OnBaseChannelReady(
     scoped_ptr<net::StreamSocket> socket) {
   base_channel_factory_ = nullptr;
   base_channel_ = socket.Pass();
 
   if (base_channel_.get()) {
     // Initialize reader and writer.
-    reader_.Init(base_channel_.get(),
-                 base::Bind(&ChannelMultiplexer::OnIncomingPacket,
-                            base::Unretained(this)));
+    reader_.StartReading(base_channel_.get());
     writer_.Init(base_channel_.get(),
                  base::Bind(&ChannelMultiplexer::OnWriteFailed,
                             base::Unretained(this)));
   }
 
   DoCreatePendingChannels();
 }
 
 void ChannelMultiplexer::DoCreatePendingChannels() {
   if (pending_channels_.empty())
@@ skipping 77 matching lines @@
   channel->OnIncomingPacket(packet.Pass(), done_task);
 }
 
 bool ChannelMultiplexer::DoWrite(scoped_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   return writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting