Remove video_channel() from Session interface

remoting/protocol/jingle_session_unittest.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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/time.h"
 #include "base/test/test_timeouts.h"
 #include "crypto/nss_util.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
+#include "net/socket/stream_socket.h"
 #include "remoting/protocol/jingle_session.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/fake_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h"
 
 using testing::_;
 using testing::AtMost;
@@ skipping 20 matching lines @@
 
 namespace {
 
 // Send 100 messages 1024 bytes each. UDP messages are sent with 10ms delay
 // between messages (about 1 second for 100 messages).
 const int kMessageSize = 1024;
 const int kMessages = 100;
 const int kTestDataSize = kMessages * kMessageSize;
 const int kUdpWriteDelayMs = 10;
 const char kTestToken[] = "a_dummy_token";
+const char kChannelName[] = "test_channel";
 
 const char kHostJid[] = "host1@gmail.com/123";
 const char kClientJid[] = "host2@gmail.com/321";
 
 const char kTestHostPublicKey[] =
     "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3nk/8ILc0JBqHgOS0UCOIl4m"
     "0GUd2FIiZ/6Fc9D/iiyUgli+FIY5dwsrSoNJ87sYGifVDh8a5fdZNV5y58CcrapI5fJI"
     "FpXviSW4g8d/t1gcZkoz1ppmjzbgXm6ckw9Td0yRD0cHu732Ijs+eo8wT0pt4KiHkbyR"
     "iAvjrvkNDlfiEk7tiY7YzD9zTi3146GX6KLz5GQAd/3I8I5QW3ftF1s/m93AHuc383GZ"
     "A78Oi+IbcJf/jJUZO119VNnRKGiPsf5GZIoHyXX8O5OUQk5soKdQPeK1FwWkeZu6fuXl"
@@ skipping 141 matching lines @@
 
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(
                 this, &JingleSessionTest::SetHostSession)),
             SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
     {
       InSequence dummy;
 
-      EXPECT_CALL(host_connection_callback_,
-                  OnStateChange(Session::CONNECTING))
-          .Times(1);
       if (shared_secret == kTestSharedSecret) {
         EXPECT_CALL(host_connection_callback_,
                     OnStateChange(Session::CONNECTED))
+            .Times(1);
+        EXPECT_CALL(host_connection_callback_,
+                    OnStateChange(Session::CONNECTED_CHANNELS))
             .Times(1)
             .WillOnce(QuitThreadOnCounter(&not_connected_peers));
         // Expect that the connection will be closed eventually.
         EXPECT_CALL(host_connection_callback_,
                     OnStateChange(Session::CLOSED))
             .Times(1);
       } else {
         // Might pass through the CONNECTED state.
         EXPECT_CALL(host_connection_callback_,
                     OnStateChange(Session::CONNECTED))
             .Times(AtMost(1));
+        EXPECT_CALL(host_connection_callback_,
+                    OnStateChange(Session::CONNECTED_CHANNELS))
+            .Times(AtMost(1));
         // Expect that the connection will be closed eventually.
         EXPECT_CALL(host_connection_callback_,
                     OnStateChange(Session::FAILED))
             .Times(1)
             .WillOnce(InvokeWithoutArgs(&QuitCurrentThread));
       }
     }
 
     {
       InSequence dummy;
 
       EXPECT_CALL(client_connection_callback_,
                   OnStateChange(Session::CONNECTING))
           .Times(1);
       if (shared_secret == kTestSharedSecret) {
         EXPECT_CALL(client_connection_callback_,
                     OnStateChange(Session::CONNECTED))
+            .Times(1);
+        EXPECT_CALL(client_connection_callback_,
+                    OnStateChange(Session::CONNECTED_CHANNELS))
             .Times(1)
             .WillOnce(QuitThreadOnCounter(&not_connected_peers));
       } else {
         EXPECT_CALL(client_connection_callback_,
                     OnStateChange(Session::CONNECTED))
             .Times(AtMost(1));
+        EXPECT_CALL(client_connection_callback_,
+                    OnStateChange(Session::CONNECTED_CHANNELS))
+            .Times(AtMost(1));
       }
       // Expect that the connection will be closed eventually.
       EXPECT_CALL(client_connection_callback_,
                   OnStateChange(Session::CLOSED))
           .Times(1);
     }
 
     client_session_.reset(client_server_->Connect(
         kHostJid, kTestHostPublicKey, kTestToken,
         CandidateSessionConfig::CreateDefault(),
@@ skipping 18 matching lines @@
   MockSessionManagerListener client_server_listener_;
 
   scoped_ptr<Session> host_session_;
   MockSessionCallback host_connection_callback_;
   scoped_ptr<Session> client_session_;
   MockSessionCallback client_connection_callback_;
 };
 
 class ChannelTesterBase : public base::RefCountedThreadSafe<ChannelTesterBase> {
  public:
-  enum ChannelType {
-    CONTROL,
-    EVENT,
-    VIDEO,
-    VIDEO_RTP,
-    VIDEO_RTCP,
-  };
-
   ChannelTesterBase(Session* host_session,
                     Session* client_session)
       : host_session_(host_session),
         client_session_(client_session),
         done_(false) {
   }
 
   virtual ~ChannelTesterBase() { }
 
-  void Start(ChannelType channel) {
+  void Start() {
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &ChannelTesterBase::DoStart,
-                                     channel));
+        FROM_HERE, NewRunnableMethod(this, &ChannelTesterBase::DoStart));
   }
 
   bool WaitFinished() {
     return RunMessageLoopWithTimeout(TestTimeouts::action_max_timeout_ms());
   }
 
   virtual void CheckResults() = 0;
 
  protected:
-  void DoStart(ChannelType channel) {
-    socket_1_ = SelectChannel(host_session_, channel);
-    socket_2_ = SelectChannel(client_session_, channel);
+  void DoStart() {
+    InitChannels();
+  }
 
-    InitBuffers();
-    DoRead();
-    DoWrite();
-  }
+  virtual void InitChannels() = 0;
 
   void Done() {
     done_ = true;
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(&QuitCurrentThread));
   }
 
   virtual void InitBuffers() = 0;
   virtual void DoWrite() = 0;
   virtual void DoRead() = 0;
 
-  net::Socket* SelectChannel(Session* session,
-                             ChannelType channel) {
-    switch (channel) {
-      case CONTROL:
-        return session->control_channel();
-      case EVENT:
-        return session->event_channel();
-      case VIDEO:
-        return session->video_channel();
-      case VIDEO_RTP:
-        return session->video_rtp_channel();
-      case VIDEO_RTCP:
-        return session->video_rtcp_channel();
-      default:
-        NOTREACHED();
-        return NULL;
-    }
-  }
-
   Session* host_session_;
   Session* client_session_;
-  net::Socket* socket_1_;
-  net::Socket* socket_2_;
+  scoped_ptr<net::Socket> sockets_[2];
   bool done_;
 };
 
 class TCPChannelTester : public ChannelTesterBase {
  public:
   TCPChannelTester(Session* host_session,
                    Session* client_session,
                    int message_size,
                    int message_count)
       : ChannelTesterBase(host_session, client_session),
@@ skipping 17 matching lines @@
     ASSERT_EQ(test_data_size_, input_buffer_->offset());
 
     output_buffer_->SetOffset(0);
     ASSERT_EQ(test_data_size_, output_buffer_->size());
 
     EXPECT_EQ(0, memcmp(output_buffer_->data(),
                         input_buffer_->StartOfBuffer(), test_data_size_));
   }
 
  protected:
+  virtual void InitChannels() OVERRIDE {
+    host_session_->CreateStreamChannel(
+        kChannelName,
+        base::Bind(&TCPChannelTester::OnChannelReady,
+                   base::Unretained(this), 0));
+    client_session_->CreateStreamChannel(
+        kChannelName,
+        base::Bind(&TCPChannelTester::OnChannelReady,
+                   base::Unretained(this), 1));
+  }
+
+  void OnChannelReady(int id, const std::string name,
+                      net::StreamSocket* socket) {
+    ASSERT_TRUE(socket);
+    ASSERT_EQ(name, kChannelName);
+    if (!socket) {
+      Done();
+      return;
+    }
+
+    DCHECK(id >= 0 && id < 2);
+    sockets_[id].reset(socket);
+
+    if (sockets_[0].get() && sockets_[1].get()) {
+      InitBuffers();
+      DoRead();
+      DoWrite();
+    }
+  }
+
   virtual void InitBuffers() {
     output_buffer_ = new net::DrainableIOBuffer(
         new net::IOBuffer(test_data_size_), test_data_size_);
     memset(output_buffer_->data(), 123, test_data_size_);
 
     input_buffer_ = new net::GrowableIOBuffer();
   }
 
   virtual void DoWrite() {
     int result = 1;
     while (result > 0) {
       if (output_buffer_->BytesRemaining() == 0)
         break;
       int bytes_to_write = std::min(output_buffer_->BytesRemaining(),
                                     message_size_);
-      result = socket_1_->Write(output_buffer_, bytes_to_write, &write_cb_);
+      result = sockets_[0]->Write(output_buffer_, bytes_to_write, &write_cb_);
       HandleWriteResult(result);
     };
   }
 
   void OnWritten(int result) {
     HandleWriteResult(result);
     DoWrite();
   }
 
   void HandleWriteResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       LOG(ERROR) << "Received error " << result << " when trying to write";
       write_errors_++;
       Done();
     } else if (result > 0) {
       output_buffer_->DidConsume(result);
     }
   }
 
   virtual void DoRead() {
     int result = 1;
     while (result > 0) {
       input_buffer_->SetCapacity(input_buffer_->offset() + message_size_);
-      result = socket_2_->Read(input_buffer_, message_size_, &read_cb_);
+      result = sockets_[1]->Read(input_buffer_, message_size_, &read_cb_);
       HandleReadResult(result);
     };
   }
 
   void OnRead(int result) {
     HandleReadResult(result);
     if (!done_)
       DoRead();  // Don't try to read again when we are done reading.
   }
 
@@ skipping 76 matching lines @@
 
     EXPECT_EQ(0, broken_packets_);
 
     // Verify that we've received at least one packet.
     EXPECT_GT(packets_received_, 0);
     LOG(INFO) << "Received " << packets_received_ << " packets out of "
               << kMessages;
   }
 
  protected:
+  virtual void InitChannels() OVERRIDE {
+    host_session_->CreateDatagramChannel(
+        kChannelName,
+        base::Bind(&UDPChannelTester::OnChannelReady,
+                   base::Unretained(this), 0));
+    client_session_->CreateDatagramChannel(
+        kChannelName,
+        base::Bind(&UDPChannelTester::OnChannelReady,
+                   base::Unretained(this), 1));
+  }
+
+  void OnChannelReady(int id, const std::string name, net::Socket* socket) {
+    ASSERT_TRUE(socket);
+    ASSERT_EQ(name, kChannelName);
+    if (!socket) {
+      Done();
+      return;
+    }
+
+    DCHECK(id >= 0 && id < 2);
+    sockets_[id].reset(socket);
+
+    if (sockets_[0].get() && sockets_[1].get()) {
+      InitBuffers();
+      DoRead();
+      DoWrite();
+    }
+  }
+
+
   virtual void InitBuffers() {
   }
 
   virtual void DoWrite() {
     if (packets_sent_ >= kMessages) {
       Done();
       return;
     }
 
     scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(kMessageSize));
     memset(packet->data(), 123, kMessageSize);
     sent_packets_[packets_sent_] = packet;
     // Put index of this packet in the beginning of the packet body.
     memcpy(packet->data(), &packets_sent_, sizeof(packets_sent_));
 
-    int result = socket_1_->Write(packet, kMessageSize, &write_cb_);
+    int result = sockets_[0]->Write(packet, kMessageSize, &write_cb_);
     HandleWriteResult(result);
   }
 
   void OnWritten(int result) {
     HandleWriteResult(result);
   }
 
   void HandleWriteResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       LOG(ERROR) << "Received error " << result << " when trying to write";
       write_errors_++;
       Done();
     } else if (result > 0) {
       EXPECT_EQ(kMessageSize, result);
       packets_sent_++;
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE, NewRunnableMethod(this, &UDPChannelTester::DoWrite),
           kUdpWriteDelayMs);
     }
   }
 
   virtual void DoRead() {
     int result = 1;
     while (result > 0) {
       int kReadSize = kMessageSize * 2;
       read_buffer_ = new net::IOBuffer(kReadSize);
 
-      result = socket_2_->Read(read_buffer_, kReadSize, &read_cb_);
+      result = sockets_[1]->Read(read_buffer_, kReadSize, &read_cb_);
       HandleReadResult(result);
     };
   }
 
   void OnRead(int result) {
     HandleReadResult(result);
     DoRead();
   }
 
   void HandleReadResult(int result) {
@@ skipping 78 matching lines @@
   ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
 }
 
 // Verify that we can't connect two endpoints with mismatched secrets.
 TEST_F(JingleSessionTest, ConnectBadChannelAuth) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection(kTestSharedSecretBad));
 }
 
 // Verify that data can be transmitted over the event channel.
-TEST_F(JingleSessionTest, TestControlChannel) {
+TEST_F(JingleSessionTest, TestTcpChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
   scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(host_session_.get(), client_session_.get(),
                            kMessageSize, kMessages));
-  tester->Start(ChannelTesterBase::CONTROL);
+  tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
-  // Connections must be closed while |tester| still exists.
-  CloseSessions();
-}
-
-// Verify that data can be transmitted over the video channel.
-TEST_F(JingleSessionTest, TestVideoChannel) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
-  scoped_refptr<TCPChannelTester> tester(
-      new TCPChannelTester(host_session_.get(), client_session_.get(),
-                           kMessageSize, kMessageSize));
-  tester->Start(ChannelTesterBase::VIDEO);
-  ASSERT_TRUE(tester->WaitFinished());
-  tester->CheckResults();
-
-  // Connections must be closed while |tester| still exists.
-  CloseSessions();
-}
-
-// Verify that data can be transmitted over the event channel.
-TEST_F(JingleSessionTest, TestEventChannel) {
-  CreateServerPair();
-  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
-  scoped_refptr<TCPChannelTester> tester(
-      new TCPChannelTester(host_session_.get(), client_session_.get(),
-                           kMessageSize, kMessageSize));
-  tester->Start(ChannelTesterBase::EVENT);
-  ASSERT_TRUE(tester->WaitFinished());
-  tester->CheckResults();
-
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Verify that data can be transmitted over the video RTP channel.
-// Disabled because RTP support is disabled, see crbug.com/91538 .
-TEST_F(JingleSessionTest, DISABLED_TestVideoRtpChannel) {
+TEST_F(JingleSessionTest, TestUdpChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
   scoped_refptr<UDPChannelTester> tester(
       new UDPChannelTester(host_session_.get(), client_session_.get()));
-  tester->Start(ChannelTesterBase::VIDEO_RTP);
+  tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Send packets of different size to get the latency for sending data
 // using sockets from JingleSession.
 TEST_F(JingleSessionTest, TestSpeed) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
   scoped_refptr<ChannelSpeedTester> tester;
 
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 512);
-  tester->Start(ChannelTesterBase::VIDEO);
+  tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 512 bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
+  CloseSessions();
+  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 1024);
-  tester->Start(ChannelTesterBase::VIDEO);
+  tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 1024 bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
+  CloseSessions();
+  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 51200);
-  tester->Start(ChannelTesterBase::VIDEO);
+  tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 50k bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
+  CloseSessions();
+  ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
+
   tester = new ChannelSpeedTester(host_session_.get(),
                                   client_session_.get(), 512000);
-  tester->Start(ChannelTesterBase::VIDEO);
+  tester->Start();
   ASSERT_TRUE(tester->WaitFinished());
   LOG(INFO) << "Time for 500k bytes "
             << tester->GetElapsedTime().InMilliseconds() << " ms.";
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 }  // namespace protocol
 }  // namespace remoting