Cleanup ChannelFactory 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 40 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PendingPacket);
 };
 
 }  // namespace
 
 const char ChannelMultiplexer::kMuxChannelName[] = "mux";
 
 struct ChannelMultiplexer::PendingChannel {
   PendingChannel(const std::string& name,
-                 const StreamChannelCallback& callback)
+                 const ChannelCreatedCallback& callback)
       : name(name), callback(callback) {
   }
   std::string name;
-  StreamChannelCallback callback;
+  ChannelCreatedCallback callback;
 };
 
 class ChannelMultiplexer::MuxChannel {
  public:
   MuxChannel(ChannelMultiplexer* multiplexer, const std::string& name,
              int send_id);
   ~MuxChannel();
 
   const std::string& name() { return name_; }
   int receive_id() { return receive_id_; }
@@ skipping 287 matching lines @@
 
 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_);
 }
 
-void ChannelMultiplexer::CreateStreamChannel(
-    const std::string& name,
-    const StreamChannelCallback& callback) {
+void ChannelMultiplexer::CreateChannel(const std::string& name,
+                                       const ChannelCreatedCallback& 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_factory_->CreateChannel(
           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>());
-}
-
 void ChannelMultiplexer::CancelChannelCreation(const std::string& name) {
   for (std::list<PendingChannel>::iterator it = pending_channels_.begin();
        it != pending_channels_.end(); ++it) {
     if (it->name == name) {
       pending_channels_.erase(it);
       return;
     }
   }
 }
 
@@ skipping 97 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