Parse termination reason and propagate the error to the 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 16 matching lines @@
 // message. This is neccessary to be able to pack multiple candidates
 // into one transport-info messages. The value needs to be greater
 // than zero because ports are opened asynchronously in the browser
 // process.
 const int kTransportInfoSendDelayMs = 2;
 }  // namespace
 
 PepperSession::PepperSession(PepperSessionManager* session_manager)
     : session_manager_(session_manager),
       state_(INITIALIZING),
-      error_(ERROR_NO_ERROR) {
+      error_(OK) {
 }
 
 PepperSession::~PepperSession() {
   control_channel_socket_.reset();
   event_channel_socket_.reset();
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   session_manager_->SessionDestroyed(this);
 }
 
-PepperSession::Error PepperSession::error() {
-  DCHECK(CalledOnValidThread());
-  return error_;
-}
-
 void PepperSession::SetStateChangeCallback(StateChangeCallback* callback) {
   DCHECK(CalledOnValidThread());
   state_change_callback_.reset(callback);
 }
 
+Session::Error PepperSession::error() {
+  DCHECK(CalledOnValidThread());
+  return error_;
+}
+
 void PepperSession::StartConnection(
     const std::string& peer_jid,
     const std::string& peer_public_key,
     const std::string& client_token,
     CandidateSessionConfig* config,
     Session::StateChangeCallback* state_change_callback) {
   DCHECK(CalledOnValidThread());
 
   peer_jid_ = peer_jid;
   peer_public_key_ = peer_public_key;
@@ skipping 24 matching lines @@
 void PepperSession::OnSessionInitiateResponse(
     const buzz::XmlElement* response) {
   const std::string& type = response->Attr(buzz::QName("", "type"));
   if (type != "result") {
     LOG(ERROR) << "Received error in response to session-initiate message: \""
                << response->Str()
                << "\" Terminating the session.";
 
     // TODO(sergeyu): There may be different reasons for error
     // here. Parse the response stanza to find failure reason.
-    OnError(ERROR_PEER_IS_OFFLINE);
+    OnError(PEER_IS_OFFLINE);
   }
 }
 
 void PepperSession::OnError(Error error) {
   error_ = error;
   CloseInternal(true);
 }
 
 void PepperSession::CreateStreamChannel(
       const std::string& name,
@@ skipping 103 matching lines @@
 
   switch (message.action) {
     case JingleMessage::SESSION_ACCEPT:
       OnAccept(message, reply);
       break;
 
     case JingleMessage::TRANSPORT_INFO:
       ProcessTransportInfo(message);
       break;
 
-    case JingleMessage::SESSION_REJECT:
-      OnReject(message, reply);
-      break;
-
     case JingleMessage::SESSION_TERMINATE:
       OnTerminate(message, reply);
       break;
 
     default:
       *reply = JingleMessageReply(JingleMessageReply::UNEXPECTED_REQUEST);
   }
 }
 
 void PepperSession::OnAccept(const JingleMessage& message,
                              JingleMessageReply* reply) {
   if (state_ != CONNECTING) {
     *reply = JingleMessageReply(JingleMessageReply::UNEXPECTED_REQUEST);
     return;
   }
 
   if (!InitializeConfigFromDescription(message.description.get())) {
-    OnError(ERROR_INCOMPATIBLE_PROTOCOL);
+    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) {
     ChannelsMap::iterator channel = channels_.find(it->name());
     if (channel == channels_.end()) {
       LOG(WARNING) << "Received candidate for unknown channel " << it->name();
       continue;
     }
     channel->second->AddRemoveCandidate(*it);
   }
 }
 
-void PepperSession::OnReject(const JingleMessage& message,
-                             JingleMessageReply* reply) {
-  if (state_ != CONNECTING) {
-    *reply = JingleMessageReply(JingleMessageReply::UNEXPECTED_REQUEST);
-    return;
-  }
-
-  // TODO(sergeyu): Parse exact rejection reason from reply and pass it
-  // to OnError().
-  OnError(ERROR_SESSION_REJECTED);
-}
-
 void PepperSession::OnTerminate(const JingleMessage& message,
                                 JingleMessageReply* reply) {
   if (state_ == CONNECTING) {
-    // If we are not connected yet, then interpret terminate message
-    // as rejection.
-    OnError(ERROR_SESSION_REJECTED);
+    switch (message.reason) {
+      case JingleMessage::DECLINED:
+        OnError(SESSION_REJECTED);
+        break;
+
+      case JingleMessage::INCOMPATIBLE_PARAMETERS:
+        OnError(INCOMPATIBLE_PROTOCOL);
+        break;
+
+      default:
+        LOG(WARNING) << "Received session-terminate message "
+            "with an unexpected reason.";
+        OnError(SESSION_REJECTED);
+    }
     return;
   }
 
   CloseInternal(false);
 }
 
 bool PepperSession::InitializeConfigFromDescription(
     const ContentDescription* description) {
   DCHECK(description);
 
@@ skipping 50 matching lines @@
       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(ERROR_CHANNEL_CONNECTION_FAILURE);
+    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) {
@@ skipping 18 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (state_change_callback_.get())
       state_change_callback_->Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting