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 219 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),
+        socket_1_(NULL),
+        socket_2_(NULL),
         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_;
   bool done_;
 };
 
 class TCPChannelTester : public ChannelTesterBase {
  public:
   TCPChannelTester(Session* host_session,
@@ skipping 21 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;
+    }
+
+    switch (id) {
+      case 0:
+        socket_1_ = socket;
+        break;
+
+      case 1:
+        socket_2_ = socket;
+        break;
+
+      default:
+        NOTREACHED();
+    }
+
+    if (socket_1_ && socket_2_) {
+      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;
@@ skipping 116 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;
+    }
+
+    switch (id) {
+      case 0:
+        socket_1_ = socket;

[Wez, 2011/08/04 23:49:52]

nit: Simpler to use an array of two sockets, here and above?

[Sergey Ulanov, 2011/08/09 19:41:10]

Done.

+        break;
+
+      case 1:
+        socket_2_ = socket;
+        break;
+
+      default:
+        NOTREACHED();
+    }
+
+    if (socket_1_ && socket_2_) {
+      InitBuffers();
+      DoRead();
+      DoWrite();
+    }
+  }
+
+
   virtual void InitBuffers() {
   }
 
   virtual void DoWrite() {
     if (packets_sent_ >= kMessages) {
       Done();
       return;
     }
 
     scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(kMessageSize));
@@ skipping 122 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