Remove event_channel() and control_channel() from Session interface.

remoting/protocol/pepper_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/pepper_session.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 20 matching lines @@
 const int kTransportInfoSendDelayMs = 2;
 }  // namespace
 
 PepperSession::PepperSession(PepperSessionManager* session_manager)
     : session_manager_(session_manager),
       state_(INITIALIZING),
       error_(OK) {
 }
 
 PepperSession::~PepperSession() {
-  control_channel_socket_.reset();
-  event_channel_socket_.reset();
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   session_manager_->SessionDestroyed(this);
 }
 
 void PepperSession::SetStateChangeCallback(
     const StateChangeCallback& callback) {
   DCHECK(CalledOnValidThread());
   state_change_callback_ = callback;
 }
 
@@ skipping 74 matching lines @@
 }
 
 void PepperSession::CancelChannelCreation(const std::string& name) {
   ChannelsMap::iterator it = channels_.find(name);
   if (it != channels_.end() && !it->second->is_connected()) {
     delete it->second;
     DCHECK(!channels_[name]);
   }
 }
 
-net::Socket* PepperSession::control_channel() {
-  DCHECK(CalledOnValidThread());
-  return control_channel_socket_.get();
-}
-
-net::Socket* PepperSession::event_channel() {
-  DCHECK(CalledOnValidThread());
-  return event_channel_socket_.get();
-}
-
 const std::string& PepperSession::jid() {
   DCHECK(CalledOnValidThread());
   return peer_jid_;
 }
 
 const CandidateSessionConfig* PepperSession::candidate_config() {
   DCHECK(CalledOnValidThread());
   return candidate_config_.get();
 }
 
@@ skipping 35 matching lines @@
 }
 
 const std::string& PepperSession::shared_secret() {
   DCHECK(CalledOnValidThread());
   return shared_secret_;
 }
 
 void PepperSession::Close() {
   DCHECK(CalledOnValidThread());
 
-  if (state_ == CONNECTING || state_ == CONNECTED ||
-      state_ == CONNECTED_CHANNELS) {
+  if (state_ == CONNECTING || state_ == CONNECTED) {
     // Send session-terminate message.
     JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
                           session_id_);
     scoped_ptr<IqRequest> terminate_request(
         session_manager_->iq_sender()->SendIq(
             message.ToXml(), IqSender::ReplyCallback()));
   }
 
   CloseInternal(false);
 }
@@ skipping 31 matching lines @@
   if (state_ != CONNECTING) {
     *reply = JingleMessageReply(JingleMessageReply::UNEXPECTED_REQUEST);
     return;
   }
 
   if (!InitializeConfigFromDescription(message.description.get())) {
     OnError(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
-  CreateChannels();
   SetState(CONNECTED);
 
    // In case there is transport information in the accept message.
   ProcessTransportInfo(message);
 }
 
 void PepperSession::ProcessTransportInfo(const JingleMessage& message) {
   for (std::list<cricket::Candidate>::const_iterator it =
            message.candidates.begin();
        it != message.candidates.end(); ++it) {
@@ skipping 19 matching lines @@
         break;
 
       default:
         LOG(WARNING) << "Received session-terminate message "
             "with an unexpected reason.";
         OnError(SESSION_REJECTED);
     }
     return;
   }
 
-  // TODO(sergeyu): We should return CHANNEL_CONNECTION_ERROR only in
-  // case when |message.reason| is set GENERAL_ERROR, but some legacy
-  // hosts may sent terminate messages with reason set to SUCCESS.
   if (state_ == CONNECTED) {
-    // Session was connected, but we failed to connect channels.
-    OnError(CHANNEL_CONNECTION_ERROR);
+    if (message.reason == JingleMessage::GENERAL_ERROR) {
+      OnError(CHANNEL_CONNECTION_ERROR);
+    } else {
+      CloseInternal(false);
+    }
     return;
   }
 
-  CloseInternal(false);
+  LOG(ERROR) << "Received unexpected session-terminate message.";

[Wez, 2011/11/21 02:39:04]

Is that really an error?

[Sergey Ulanov, 2011/11/21 22:14:22]

Changed to WARNING.

 }
 
 bool PepperSession::InitializeConfigFromDescription(
     const ContentDescription* description) {
   DCHECK(description);
 
   remote_cert_ = description->certificate();
   if (remote_cert_.empty()) {
     LOG(ERROR) << "session-accept does not specify certificate";
     return false;
@@ skipping 47 matching lines @@
 
 void PepperSession::SendTransportInfo() {
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.candidates.swap(pending_candidates_);
   transport_info_request_.reset(session_manager_->iq_sender()->SendIq(
       message.ToXml(), base::Bind(
           &PepperSession::OnTransportInfoResponse,
           base::Unretained(this))));
 }
 
-void PepperSession::CreateChannels() {
-   CreateStreamChannel(
-      kControlChannelName,
-      base::Bind(&PepperSession::OnChannelConnected,
-                 base::Unretained(this), &control_channel_socket_));
-  CreateStreamChannel(
-      kEventChannelName,
-      base::Bind(&PepperSession::OnChannelConnected,
-                 base::Unretained(this), &event_channel_socket_));
-}
-
-void PepperSession::OnChannelConnected(
-    scoped_ptr<net::Socket>* socket_container,
-    net::StreamSocket* socket) {
-  if (!socket) {
-    LOG(ERROR) << "Failed to connect control or events channel. "
-               << "Terminating connection";
-    OnError(CHANNEL_CONNECTION_ERROR);
-    return;
-  }
-
-  socket_container->reset(socket);
-
-  if (control_channel_socket_.get() && event_channel_socket_.get())
-    SetState(CONNECTED_CHANNELS);
-}
 
 void PepperSession::CloseInternal(bool failed) {
   DCHECK(CalledOnValidThread());
 
   if (state_ != FAILED && state_ != CLOSED) {
-    control_channel_socket_.reset();
-    event_channel_socket_.reset();
-
     if (failed)
       SetState(FAILED);
     else
       SetState(CLOSED);
   }
 }
 
 void PepperSession::SetState(State new_state) {
   DCHECK(CalledOnValidThread());
 
   if (new_state != state_) {
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting