Remove event_channel() and control_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/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/time.h"
@@ skipping 201 matching lines @@
 
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(DoAll(
             WithArg<0>(Invoke(
                 this, &JingleSessionTest::SetHostSession)),
             SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
 
     {
       InSequence dummy;
 
-      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(AtMost(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 fail.
-        EXPECT_CALL(host_connection_callback_,
-                    OnStateChange(Session::FAILED))
-            .Times(1)
-            .WillOnce(InvokeWithoutArgs(&QuitCurrentThread));
-      }
+      EXPECT_CALL(host_connection_callback_,
+                  OnStateChange(Session::CONNECTED))
+          .Times(1)
+          .WillOnce(QuitThreadOnCounter(&not_connected_peers));
+      // Expect that the connection will be closed eventually.
+      EXPECT_CALL(host_connection_callback_,
+                  OnStateChange(Session::CLOSED))
+          .Times(AtMost(1));
     }
 
     {
       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_CALL(client_connection_callback_,
+                  OnStateChange(Session::CONNECTED))
+          .Times(1)
+          .WillOnce(QuitThreadOnCounter(&not_connected_peers));
       // Expect that the connection will be closed eventually.
       EXPECT_CALL(client_connection_callback_,
                   OnStateChange(Session::CLOSED))
           .Times(AtMost(1));
     }
 
     client_session_.reset(client_server_->Connect(
         kHostJid, kTestHostPublicKey, kTestToken,
         CandidateSessionConfig::CreateDefault(),
         base::Bind(&MockSessionCallback::OnStateChange,
@@ skipping 79 matching lines @@
             read_cb_(this, &TCPChannelTester::OnRead)),
         write_errors_(0),
         read_errors_(0),
         message_size_(message_size),
         message_count_(message_count),
         test_data_size_(message_size * message_count) {
   }
 
   virtual ~TCPChannelTester() { }
 
+  virtual bool did_initialization_fail() {
+    return !sockets_[0].get() || !sockets_[1].get();
+  }
+
   virtual void CheckResults() {
+    ASSERT_FALSE(did_initialization_fail());
+
     EXPECT_EQ(0, write_errors_);
     EXPECT_EQ(0, read_errors_);
 
     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, net::StreamSocket* socket) {
-    ASSERT_TRUE(socket);
     if (!socket) {
       Done();
       return;
     }
 
     DCHECK(id >= 0 && id < 2);
     sockets_[id].reset(socket);
 
     if (sockets_[0].get() && sockets_[1].get()) {
       InitBuffers();
@@ skipping 299 matching lines @@
 // Verify that we can connect two endpoints.
 TEST_F(JingleSessionTest, Connect) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection(kTestSharedSecret));
 }
 
 // Verify that we can't connect two endpoints with mismatched secrets.
 TEST_F(JingleSessionTest, ConnectBadChannelAuth) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection(kTestSharedSecretBad));
+  scoped_refptr<TCPChannelTester> tester(
+      new TCPChannelTester(host_session_.get(), client_session_.get(),
+                           kMessageSize, kMessages));
+  tester->Start();
+  ASSERT_TRUE(tester->WaitFinished());
+  EXPECT_TRUE(tester->did_initialization_fail());
+
+  CloseSessions();
 }
 
 // Verify that data can be transmitted over the event channel.
 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();
@@ skipping 61 matching lines @@
   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