Simplify channel creation callbacks in remoting::Session interface.

Remove name parameters from StreamChannelCallback and
DatagramChannelCallback. This argument is redundant: callback currying
can be used instead where neccessary.

BUG=None
TEST=compiles.

Review URL: http://codereview.chromium.org/7605018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@96310 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 46 insertions, 64 deletions

diff --git a/remoting/protocol/fake_session.cc b/remoting/protocol/fake_session.cc
index a2496a7..6579208 100644
--- a/remoting/protocol/fake_session.cc
+++ b/remoting/protocol/fake_session.cc
@@ -210,17 +210,16 @@ void FakeSession::SetStateChangeCallback(StateChangeCallback* callback) {
 
 void FakeSession::CreateStreamChannel(
     const std::string& name, const StreamChannelCallback& callback) {
-  LOG(ERROR) << " creating channel " << name;
   FakeSocket* channel = new FakeSocket();
   stream_channels_[name] = channel;
-  callback.Run(name, channel);
+  callback.Run(channel);
 }
 
 void FakeSession::CreateDatagramChannel(
     const std::string& name, const DatagramChannelCallback& callback) {
   FakeUdpSocket* channel = new FakeUdpSocket();
   datagram_channels_[name] = channel;
-  callback.Run(name, channel);
+  callback.Run(channel);
 }
 
 FakeSocket* FakeSession::control_channel() {
diff --git a/remoting/protocol/jingle_datagram_connector.cc b/remoting/protocol/jingle_datagram_connector.cc
index 5a789d1..4a90b3d 100644
--- a/remoting/protocol/jingle_datagram_connector.cc
+++ b/remoting/protocol/jingle_datagram_connector.cc
@@ -36,7 +36,7 @@ void JingleDatagramConnector::Connect(
   // TODO(sergeyu): Implement encryption for datagram channels.
 
   session_->OnChannelConnectorFinished(name_, this);
-  callback_.Run(name_, socket);
+  callback_.Run(socket);
   delete this;
 }
 
diff --git a/remoting/protocol/jingle_session.cc b/remoting/protocol/jingle_session.cc
index 8c8f14f..f5ac3ab 100644
--- a/remoting/protocol/jingle_session.cc
+++ b/remoting/protocol/jingle_session.cc
@@ -489,34 +489,27 @@ void JingleSession::OnChannelConnectorFinished(
 }
 
 void JingleSession::CreateChannels() {
-  StreamChannelCallback stream_callback(
-      base::Bind(&JingleSession::OnStreamChannelConnected,
-                 base::Unretained(this)));
-  CreateStreamChannel(kControlChannelName, stream_callback);
-  CreateStreamChannel(kEventChannelName, stream_callback);
-}
-
-void JingleSession::OnStreamChannelConnected(const std::string& name,
-                                             net::StreamSocket* socket) {
-  OnChannelConnected(name, socket);
-}
-
-void JingleSession::OnChannelConnected(const std::string& name,
-                                       net::Socket* socket) {
+  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::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())
     SetState(CONNECTED_CHANNELS);
diff --git a/remoting/protocol/jingle_session.h b/remoting/protocol/jingle_session.h
index 7ac6fac..e4e3a6f 100644
--- a/remoting/protocol/jingle_session.h
+++ b/remoting/protocol/jingle_session.h
@@ -124,9 +124,8 @@ class JingleSession : public protocol::Session,
   // Callbacks for the channels created in JingleSession.
   // TODO(sergeyu): Remove this method once *_channel() methods are
   // removed from Session interface.
-  void OnStreamChannelConnected(
-      const std::string& name, net::StreamSocket* socket);
-  void OnChannelConnected(const std::string& name, net::Socket* socket);
+  void OnChannelConnected(scoped_ptr<net::Socket>* socket_container,
+                          net::StreamSocket* socket);
 
   const cricket::ContentInfo* GetContentInfo() const;
 
diff --git a/remoting/protocol/jingle_session_unittest.cc b/remoting/protocol/jingle_session_unittest.cc
index 1a53c6e..aab1df8 100644
--- a/remoting/protocol/jingle_session_unittest.cc
+++ b/remoting/protocol/jingle_session_unittest.cc
@@ -390,10 +390,8 @@ class TCPChannelTester : public ChannelTesterBase {
                    base::Unretained(this), 1));
   }
 
-  void OnChannelReady(int id, const std::string name,
-                      net::StreamSocket* socket) {
+  void OnChannelReady(int id, net::StreamSocket* socket) {
     ASSERT_TRUE(socket);
-    ASSERT_EQ(name, kChannelName);
     if (!socket) {
       Done();
       return;
@@ -556,9 +554,8 @@ class UDPChannelTester : public ChannelTesterBase {
                    base::Unretained(this), 1));
   }
 
-  void OnChannelReady(int id, const std::string name, net::Socket* socket) {
+  void OnChannelReady(int id, net::Socket* socket) {
     ASSERT_TRUE(socket);
-    ASSERT_EQ(name, kChannelName);
     if (!socket) {
       Done();
       return;
diff --git a/remoting/protocol/jingle_stream_connector.cc b/remoting/protocol/jingle_stream_connector.cc
index 6ee07fb..228fd3f 100644
--- a/remoting/protocol/jingle_stream_connector.cc
+++ b/remoting/protocol/jingle_stream_connector.cc
@@ -224,7 +224,7 @@ void JingleStreamConnector::OnAuthenticationDone(
 
 void JingleStreamConnector::NotifyDone(net::StreamSocket* socket) {
   session_->OnChannelConnectorFinished(name_, this);
-  callback_.Run(name_, socket);
+  callback_.Run(socket);
   delete this;
 }
 
diff --git a/remoting/protocol/protobuf_video_reader.cc b/remoting/protocol/protobuf_video_reader.cc
index f93f2fb..08b1828 100644
--- a/remoting/protocol/protobuf_video_reader.cc
+++ b/remoting/protocol/protobuf_video_reader.cc
@@ -32,9 +32,7 @@ void ProtobufVideoReader::Init(protocol::Session* session,
       base::Bind(&ProtobufVideoReader::OnChannelReady, base::Unretained(this)));
 }
 
-void ProtobufVideoReader::OnChannelReady(const std::string& name,
-                                         net::StreamSocket* socket) {
-  DCHECK_EQ(name, std::string(kVideoChannelName));
+void ProtobufVideoReader::OnChannelReady(net::StreamSocket* socket) {
   if (!socket) {
     initialized_callback_.Run(false);
     return;
diff --git a/remoting/protocol/protobuf_video_reader.h b/remoting/protocol/protobuf_video_reader.h
index 165a3a8..a8d646c 100644
--- a/remoting/protocol/protobuf_video_reader.h
+++ b/remoting/protocol/protobuf_video_reader.h
@@ -30,7 +30,7 @@ class ProtobufVideoReader : public VideoReader {
                     const InitializedCallback& callback) OVERRIDE;
 
  private:
-  void OnChannelReady(const std::string& name, net::StreamSocket* socket);
+  void OnChannelReady(net::StreamSocket* socket);
   void OnNewData(VideoPacket* packet, Task* done_task);
 
   InitializedCallback initialized_callback_;
diff --git a/remoting/protocol/protobuf_video_writer.cc b/remoting/protocol/protobuf_video_writer.cc
index 2d37f65..0b1705a 100644
--- a/remoting/protocol/protobuf_video_writer.cc
+++ b/remoting/protocol/protobuf_video_writer.cc
@@ -29,9 +29,7 @@ void ProtobufVideoWriter::Init(protocol::Session* session,
       base::Bind(&ProtobufVideoWriter::OnChannelReady, base::Unretained(this)));
 }
 
-void ProtobufVideoWriter::OnChannelReady(const std::string& name,
-                                         net::StreamSocket* socket) {
-  DCHECK_EQ(name, std::string(kVideoChannelName));
+void ProtobufVideoWriter::OnChannelReady(net::StreamSocket* socket) {
   if (!socket) {
     initialized_callback_.Run(false);
     return;
diff --git a/remoting/protocol/protobuf_video_writer.h b/remoting/protocol/protobuf_video_writer.h
index a5bb4fc..5c69c61 100644
--- a/remoting/protocol/protobuf_video_writer.h
+++ b/remoting/protocol/protobuf_video_writer.h
@@ -38,7 +38,7 @@ class ProtobufVideoWriter : public VideoWriter {
   virtual int GetPendingPackets() OVERRIDE;
 
  private:
-  void OnChannelReady(const std::string& name, net::StreamSocket* socket);
+  void OnChannelReady(net::StreamSocket* socket);
 
   InitializedCallback initialized_callback_;
 
diff --git a/remoting/protocol/rtp_video_reader.cc b/remoting/protocol/rtp_video_reader.cc
index 9b97961..19bf2fb 100644
--- a/remoting/protocol/rtp_video_reader.cc
+++ b/remoting/protocol/rtp_video_reader.cc
@@ -41,14 +41,15 @@ void RtpVideoReader::Init(protocol::Session* session,
 
   session->CreateDatagramChannel(
       kVideoRtpChannelName,
-      base::Bind(&RtpVideoReader::OnChannelReady, base::Unretained(this)));
+      base::Bind(&RtpVideoReader::OnChannelReady,
+                 base::Unretained(this), true));
   session->CreateDatagramChannel(
       kVideoRtcpChannelName,
-      base::Bind(&RtpVideoReader::OnChannelReady, base::Unretained(this)));
+      base::Bind(&RtpVideoReader::OnChannelReady,
+                 base::Unretained(this), false));
 }
 
-void RtpVideoReader::OnChannelReady(const std::string& name,
-                                    net::Socket* socket) {
+void RtpVideoReader::OnChannelReady(bool rtp, net::Socket* socket) {
   if (!socket) {
     if (!initialized_) {
       initialized_ = true;
@@ -57,16 +58,14 @@ void RtpVideoReader::OnChannelReady(const std::string& name,
     return;
   }
 
-  if (name == kVideoRtpChannelName) {
+  if (rtp) {
     DCHECK(!rtp_channel_.get());
     rtp_channel_.reset(socket);
     rtp_reader_.Init(socket, NewCallback(this, &RtpVideoReader::OnRtpPacket));
-  } else if (name == kVideoRtcpChannelName) {
+  } else {
     DCHECK(!rtcp_channel_.get());
     rtcp_channel_.reset(socket);
     rtcp_writer_.Init(socket);
-  } else {
-    NOTREACHED();
   }
 
   if (rtp_channel_.get() && rtcp_channel_.get()) {
diff --git a/remoting/protocol/rtp_video_reader.h b/remoting/protocol/rtp_video_reader.h
index e2eaf20e..e87f677 100644
--- a/remoting/protocol/rtp_video_reader.h
+++ b/remoting/protocol/rtp_video_reader.h
@@ -50,7 +50,7 @@ class RtpVideoReader : public VideoReader {
 
   typedef std::deque<PacketsQueueEntry> PacketsQueue;
 
-  void OnChannelReady(const std::string& name, net::Socket* socket);
+  void OnChannelReady(bool rtp, net::Socket* socket);
 
   void OnRtpPacket(const RtpPacket* rtp_packet);
   void CheckFullPacket(const PacketsQueue::iterator& pos);
diff --git a/remoting/protocol/rtp_video_writer.cc b/remoting/protocol/rtp_video_writer.cc
index 2a0f950..54b3ff0 100644
--- a/remoting/protocol/rtp_video_writer.cc
+++ b/remoting/protocol/rtp_video_writer.cc
@@ -33,14 +33,15 @@ void RtpVideoWriter::Init(protocol::Session* session,
   initialized_callback_ = callback;
   session->CreateDatagramChannel(
       kVideoRtpChannelName,
-      base::Bind(&RtpVideoWriter::OnChannelReady, base::Unretained(this)));
+      base::Bind(&RtpVideoWriter::OnChannelReady,
+                 base::Unretained(this), true));
   session->CreateDatagramChannel(
       kVideoRtcpChannelName,
-      base::Bind(&RtpVideoWriter::OnChannelReady, base::Unretained(this)));
+      base::Bind(&RtpVideoWriter::OnChannelReady,
+                 base::Unretained(this), false));
 }
 
-void RtpVideoWriter::OnChannelReady(const std::string& name,
-                                    net::Socket* socket) {
+void RtpVideoWriter::OnChannelReady(bool rtp, net::Socket* socket) {
   if (!socket) {
     if (!initialized_) {
       initialized_ = true;
@@ -49,11 +50,11 @@ void RtpVideoWriter::OnChannelReady(const std::string& name,
     return;
   }
 
-  if (name == kVideoRtpChannelName) {
+  if (rtp) {
     DCHECK(!rtp_channel_.get());
     rtp_channel_.reset(socket);
     rtp_writer_.Init(socket);
-  } else if (name == kVideoRtcpChannelName) {
+  } else {
     DCHECK(!rtcp_channel_.get());
     rtcp_channel_.reset(socket);
     // TODO(sergeyu): Use RTCP channel somehow.
diff --git a/remoting/protocol/rtp_video_writer.h b/remoting/protocol/rtp_video_writer.h
index fd7349b2..f048254 100644
--- a/remoting/protocol/rtp_video_writer.h
+++ b/remoting/protocol/rtp_video_writer.h
@@ -30,7 +30,7 @@ class RtpVideoWriter : public VideoWriter {
   virtual int GetPendingPackets() OVERRIDE;
 
  private:
-  void OnChannelReady(const std::string& name, net::Socket* socket);
+  void OnChannelReady(bool rtp, net::Socket* socket);
 
   bool initialized_;
   InitializedCallback initialized_callback_;
diff --git a/remoting/protocol/session.h b/remoting/protocol/session.h
index 088bbb2..73b85c8 100644
--- a/remoting/protocol/session.h
+++ b/remoting/protocol/session.h
@@ -50,10 +50,8 @@ class Session : public base::NonThreadSafe {
   };
 
   typedef Callback1<State>::Type StateChangeCallback;
-  typedef base::Callback<void(const std::string&, net::StreamSocket*)>
-      StreamChannelCallback;
-  typedef base::Callback<void(const std::string&, net::Socket*)>
-      DatagramChannelCallback;
+  typedef base::Callback<void(net::StreamSocket*)> StreamChannelCallback;
+  typedef base::Callback<void(net::Socket*)> DatagramChannelCallback;
 
   Session() { }
   virtual ~Session() { }