Remove video_channel() from 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 15 matching lines @@
 namespace remoting {
 
 namespace protocol {
 
 const char JingleSession::kChromotingContentName[] = "chromoting";
 
 namespace {
 
 const char kControlChannelName[] = "control";
 const char kEventChannelName[] = "event";
-const char kVideoChannelName[] = "video";
 
 const int kMasterKeyLength = 16;
 const int kChannelKeyLength = 16;
 
 std::string GenerateRandomMasterKey() {
   std::string result;
   result.resize(kMasterKeyLength);
   base::RandBytes(&result[0], result.size());
   return result;
 }
@@ skipping 106 matching lines @@
 
     // Inform the StateChangeCallback, so calling code knows not to touch any
     // channels.
     if (failed)
       SetState(FAILED);
     else
       SetState(CLOSED);
 
     control_channel_socket_.reset();
     event_channel_socket_.reset();
-    video_channel_socket_.reset();
     STLDeleteContainerPairSecondPointers(channel_connectors_.begin(),
                                          channel_connectors_.end());
 
     // Tear down the cricket session, including the cricket transport channels.
     if (cricket_session_) {
       cricket_session_->Terminate();
       cricket_session_->SignalState.disconnect(this);
     }
 
     closed_ = true;
@@ skipping 43 matching lines @@
 net::Socket* JingleSession::control_channel() {
   DCHECK(CalledOnValidThread());
   return control_channel_socket_.get();
 }
 
 net::Socket* JingleSession::event_channel() {
   DCHECK(CalledOnValidThread());
   return event_channel_socket_.get();
 }
 
-net::Socket* JingleSession::video_channel() {
-  DCHECK(CalledOnValidThread());
-  return video_channel_socket_.get();
-}
-
-net::Socket* JingleSession::video_rtp_channel() {
-  DCHECK(CalledOnValidThread());
-  NOTREACHED();
-  return NULL;
-}
-
-net::Socket* JingleSession::video_rtcp_channel() {
-  DCHECK(CalledOnValidThread());
-  NOTREACHED();
-  return NULL;
-}
-
 const std::string& JingleSession::jid() {
   // TODO(sergeyu): Fix ChromotingHost so that it doesn't call this
   // method on invalid thread and uncomment this DCHECK.
   // See crbug.com/88600 .
   // DCHECK(CalledOnValidThread());
   return jid_;
 }
 
 const CandidateSessionConfig* JingleSession::candidate_config() {
   DCHECK(CalledOnValidThread());
@@ skipping 192 matching lines @@
   // host responded with, to refer to later.
   if (cricket_session_->initiator()) {
     if (!InitializeConfigFromDescription(
             cricket_session_->remote_description())) {
       CloseInternal(net::ERR_CONNECTION_FAILED, true);
       return;
     }
   }
 
   CreateChannels();
+
+  SetState(CONNECTED);
 }
 
 void JingleSession::OnTerminate() {
   DCHECK(CalledOnValidThread());
   CloseInternal(net::ERR_CONNECTION_ABORTED, false);
 }
 
 void JingleSession::AcceptConnection() {
+  SetState(CONNECTING);
+
   if (!jingle_session_manager_->AcceptConnection(this, cricket_session_)) {
     Close();
     // Release session so that JingleSessionManager::SessionDestroyed()
     // doesn't try to call cricket::SessionManager::DestroySession() for it.
     ReleaseSession();
     delete this;
     return;
   }
-
-  // Set state to CONNECTING if the session is being accepted.
-  SetState(CONNECTING);
 }
 
 void JingleSession::AddChannelConnector(
     const std::string& name, JingleChannelConnector* connector) {
   DCHECK(channel_connectors_.find(name) == channel_connectors_.end());
 
   const std::string& content_name = GetContentInfo()->name;
   cricket::TransportChannel* raw_channel =
       cricket_session_->CreateChannel(content_name, name);
 
@@ skipping 20 matching lines @@
   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(kVideoChannelName, 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) {
   if (!socket) {
     LOG(ERROR) << "Failed to connect channel " << name
                << ". 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 if (name == kVideoChannelName) {
-    video_channel_socket_.reset(socket);
   } else {
     NOTREACHED();
   }
 
-  if (control_channel_socket_.get() && event_channel_socket_.get() &&
-      video_channel_socket_.get()) {
-    // TODO(sergeyu): State should be set to CONNECTED in OnAccept
-    // independent of the channels state.
-    SetState(CONNECTED);
-  }
+  if (control_channel_socket_.get() && event_channel_socket_.get())
+    SetState(CONNECTED_CHANNELS);
 }
 
 const cricket::ContentInfo* JingleSession::GetContentInfo() const {
   const cricket::SessionDescription* session_description;
   // If we initiate the session, we get to specify the content name. When
   // accepting one, the remote end specifies it.
   if (cricket_session_->initiator()) {
     session_description = cricket_session_->local_description();
   } else {
     session_description = cricket_session_->remote_description();
@@ skipping 13 matching lines @@
 
     state_ = new_state;
     if (!closed_ && state_change_callback_.get())
       state_change_callback_->Run(new_state);
   }
 }
 
 }  // namespace protocol
 
 }  // namespace remoting