Simplify channel creation callbacks in remoting::Session interface.

remoting/protocol/jingle_session.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/jingle_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
@@ skipping 470 matching lines @@
 }
 
 void JingleSession::OnChannelConnectorFinished(
     const std::string& name, JingleChannelConnector* connector) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(channel_connectors_[name], connector);
   channel_connectors_[name] = NULL;
 }
 
 void JingleSession::CreateChannels() {
-  StreamChannelCallback stream_callback(
-      base::Bind(&JingleSession::OnStreamChannelConnected,
-                 base::Unretained(this)));
-  CreateStreamChannel(kControlChannelName, stream_callback);
-  CreateStreamChannel(kEventChannelName, stream_callback);
+  CreateStreamChannel(
+      kControlChannelName,
+      base::Bind(&JingleSession::OnChannelConnected,
+                 base::Unretained(this), &control_channel_socket_));
+  CreateStreamChannel(
+      kEventChannelName,
+      base::Bind(&JingleSession::OnChannelConnected,
+                 base::Unretained(this), &event_channel_socket_));
 }
 
-void JingleSession::OnStreamChannelConnected(const std::string& name,
-                                             net::StreamSocket* socket) {
-  OnChannelConnected(name, socket);
-}
-
-void JingleSession::OnChannelConnected(const std::string& name,
-                                       net::Socket* socket) {
+void JingleSession::OnChannelConnected(
+    scoped_ptr<net::Socket>* socket_container,
+    net::StreamSocket* socket) {
   if (!socket) {
-    LOG(ERROR) << "Failed to connect channel " << name
-               << ". Terminating connection";
+    LOG(ERROR) << "Failed to connect control or events channel. "
+               << "Terminating connection";
     CloseInternal(net::ERR_CONNECTION_CLOSED, true);
     return;
   }
 
-  if (name == kControlChannelName) {
-    control_channel_socket_.reset(socket);
-  } else if (name == kEventChannelName) {
-    event_channel_socket_.reset(socket);
-  } else {
-    NOTREACHED();
-  }
+  socket_container->reset(socket);
 
   if (control_channel_socket_.get() && event_channel_socket_.get()) {
     // TODO(sergeyu): State should be set to CONNECTED in OnAccept
     // independent of the channels state.
     SetState(CONNECTED);
   }
 }
 
 const cricket::ContentInfo* JingleSession::GetContentInfo() const {
   const cricket::SessionDescription* session_description;
@@ skipping 19 matching lines @@
 
     state_ = new_state;
     if (!closed_ && state_change_callback_.get())
       state_change_callback_->Run(new_state);
   }
 }
 
 }  // namespace protocol
 
 }  // namespace remoting