Add support for multiplexed channels in remoting::protocol::Session interface.

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 347 matching lines @@
     cb.Run(result);
   }
 }
 
 ChannelMultiplexer::ChannelMultiplexer(ChannelFactory* factory,
                                        const std::string& base_channel_name)
     : base_channel_factory_(factory),
       base_channel_name_(base_channel_name),
       next_channel_id_(0),
       destroyed_flag_(NULL) {
-  factory->CreateStreamChannel(
-      base_channel_name,
-      base::Bind(&ChannelMultiplexer::OnBaseChannelReady,
-                 base::Unretained(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_);
 
   if (destroyed_flag_)
     *destroyed_flag_ = true;
 }
 
 void ChannelMultiplexer::CreateStreamChannel(
     const std::string& name,
     const StreamChannelCallback& callback) {
   if (base_channel_.get()) {
     // Already have |base_channel_|. Create new multiplexed channel
     // synchronously.
     callback.Run(GetOrCreateChannel(name)->CreateSocket());
   } else if (!base_channel_.get() && !base_channel_factory_) {
     // Fail synchronously if we failed to create |base_channel_|.
     callback.Run(scoped_ptr<net::StreamSocket>());
   } else {
     // Still waiting for the |base_channel_|.
     pending_channels_.push_back(PendingChannel(name, callback));
+
+    // If this is the first multiplexed channel then create the base channel.
+    if (pending_channels_.size() == 1U) {
+      base_channel_factory_->CreateStreamChannel(
+          base_channel_name_,
+          base::Bind(&ChannelMultiplexer::OnBaseChannelReady,
+                     base::Unretained(this)));
+    }
   }
 }
 
 void ChannelMultiplexer::CreateDatagramChannel(
     const std::string& name,
     const DatagramChannelCallback& callback) {
   NOTIMPLEMENTED();
   callback.Run(scoped_ptr<net::Socket>());
 }
 
@@ skipping 95 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