Cleanup error handling in the client plugin.

remoting/protocol/jingle_session.cc

 // Copyright (c) 2012 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/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 20 matching lines @@
 // 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;
 
 // How long we should wait for a response from the other end. This
 // value is used for all requests include |session-initiate| and
 // |transport-info|.
 const int kMessageResponseTimeoutSeconds = 10;
 
-Session::Error AuthRejectionReasonToError(
+ErrorCode AuthRejectionReasonToErrorCode(
     Authenticator::RejectionReason reason) {
   switch (reason) {
     case Authenticator::INVALID_CREDENTIALS:
-      return Session::AUTHENTICATION_FAILED;
+      return AUTHENTICATION_FAILED;
     case Authenticator::PROTOCOL_ERROR:
-      return Session::INCOMPATIBLE_PROTOCOL;
+      return INCOMPATIBLE_PROTOCOL;
   }
   NOTREACHED();
-  return Session::UNKNOWN_ERROR;
+  return UNKNOWN_ERROR;
 }
 
 }  // namespace
 
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       state_(INITIALIZING),
       error_(OK),
       config_is_set_(false) {
 }
@@ skipping 11 matching lines @@
   DCHECK(!callback.is_null());
   state_change_callback_ = callback;
 }
 
 void JingleSession::SetRouteChangeCallback(
     const RouteChangeCallback& callback) {
   DCHECK(CalledOnValidThread());
   route_change_callback_ = callback;
 }
 
-Session::Error JingleSession::error() {
+ErrorCode JingleSession::error() {
   DCHECK(CalledOnValidThread());
   return error_;
 }
 
 void JingleSession::StartConnection(
     const std::string& peer_jid,
     scoped_ptr<Authenticator> authenticator,
     scoped_ptr<CandidateSessionConfig> config,
     const StateChangeCallback& state_change_callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 48 matching lines @@
       initiate_message.description->authenticator_message();
 
   if (!first_auth_message) {
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
   authenticator_->ProcessMessage(first_auth_message);
   if (authenticator_->state() == Authenticator::REJECTED) {
-    CloseInternal(AuthRejectionReasonToError(
+    CloseInternal(AuthRejectionReasonToErrorCode(
         authenticator_->rejection_reason()));
     return;
   }
 
   // Send the session-accept message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
   scoped_ptr<buzz::XmlElement> auth_message;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
@@ skipping 121 matching lines @@
   } else {
     LOG(ERROR) << "Failed to send a "
                << JingleMessage::GetActionName(message.action) << " message";
   }
 }
 
 void JingleSession::OnMessageResponse(
     JingleMessage::ActionType request_type,
     IqRequest* request,
     const buzz::XmlElement* response) {
-  Error error = OK;
-
   std::string type_str = JingleMessage::GetActionName(request_type);
+  CleanupPendingRequests(request);
 
   if (!response) {
     LOG(ERROR) << type_str << " request timed out.";
-    // Most likely the session-initiate timeout indicates a problem
-    // with the signaling.
-    error = UNKNOWN_ERROR;
+    CloseInternal(SIGNALING_TIMEOUT);
   } else {
     const std::string& type = response->Attr(buzz::QName("", "type"));
     if (type != "result") {
       LOG(ERROR) << "Received error in response to " << type_str
                  << " message: \"" << response->Str()
                  << "\". Terminating the session.";
 
       switch (request_type) {
         case JingleMessage::SESSION_INFO:
           // session-info is used for the new authentication protocol,
           // and wasn't previously supported.
-          error = INCOMPATIBLE_PROTOCOL;
+          CloseInternal(INCOMPATIBLE_PROTOCOL);
+          break;
 
         default:
           // TODO(sergeyu): There may be different reasons for error
           // here. Parse the response stanza to find failure reason.
-          error = PEER_IS_OFFLINE;
+          CloseInternal(PEER_IS_OFFLINE);
       }
     }
   }
-
-  CleanupPendingRequests(request);
-
-  if (error != OK) {
-    CloseInternal(error);
-  }
 }
 
 void JingleSession::CleanupPendingRequests(IqRequest* request) {
   DCHECK(!pending_requests_.empty());
   DCHECK(request);
 
   // This method is called whenever a response to |request| is
   // received. Here we delete that request and all requests that were
   // sent before it. The idea here is that if we send messages A, B
   // and C and then suddenly receive response to C then it means that
@@ skipping 183 matching lines @@
     JingleMessage message(peer_jid_, JingleMessage::SESSION_INFO, session_id_);
     message.info = authenticator_->GetNextMessage();
     DCHECK(message.info.get());
     SendMessage(message);
   }
   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     SetState(AUTHENTICATED);
   } else if (authenticator_->state() == Authenticator::REJECTED) {
-    CloseInternal(AuthRejectionReasonToError(
+    CloseInternal(AuthRejectionReasonToErrorCode(
         authenticator_->rejection_reason()));
   }
 }
 
 void JingleSession::SendTransportInfo() {
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.candidates.swap(pending_candidates_);
   SendMessage(message);
 }
 
-void JingleSession::CloseInternal(Error error) {
+void JingleSession::CloseInternal(ErrorCode error) {
   DCHECK(CalledOnValidThread());
 
   if (state_ == CONNECTING || state_ == CONNECTED || state_ == AUTHENTICATED) {
     // Send session-terminate message with the appropriate error code.
     JingleMessage::Reason reason;
     switch (error) {
       case OK:
         reason = JingleMessage::SUCCESS;
         break;
       case SESSION_REJECTED:
@@ skipping 32 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting