Send correct termination reason when session is terminated by the host.

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/location.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
@@ skipping 64 matching lines @@
   DCHECK(CalledOnValidThread());
 
   cricket_session_ = cricket_session;
   jid_ = cricket_session_->remote_name();
   cricket_session_->SignalState.connect(
       this, &JingleSession::OnSessionState);
   cricket_session_->SignalError.connect(
       this, &JingleSession::OnSessionError);
 }
 
-void JingleSession::CloseInternal(int result, bool failed) {
+void JingleSession::CloseInternal(int result, Error error) {
   DCHECK(CalledOnValidThread());
 
   if (state_ != FAILED && state_ != CLOSED && !closing_) {
     closing_ = true;
 
     control_channel_socket_.reset();
     event_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();
+      std::string reason;
+      switch (error) {
+        case OK:
+          reason = cricket::STR_TERMINATE_SUCCESS;
+          break;
+        case PEER_IS_OFFLINE:
+          reason = cricket::STR_TERMINATE_ERROR;
+          break;
+        case SESSION_REJECTED:
+          reason = cricket::STR_TERMINATE_DECLINE;
+          break;
+        case INCOMPATIBLE_PROTOCOL:
+          reason = cricket::STR_TERMINATE_INCOMPATIBLE_PARAMETERS;
+          break;
+        case CHANNEL_CONNECTION_ERROR:
+          reason = cricket::STR_TERMINATE_ERROR;
+          break;
+      }
+      cricket_session_->TerminateWithReason(reason);
       cricket_session_->SignalState.disconnect(this);
     }
 
+    error_ = error;
+
     // Inform the StateChangeCallback, so calling code knows not to
     // touch any channels. Needs to be done in the end because the
     // session may be deleted in response to this event.
-    if (failed)
+    if (error != OK) {
       SetState(FAILED);
-    else
+    } else {
       SetState(CLOSED);
+    }
   }
 }
 
 bool JingleSession::HasSession(cricket::Session* cricket_session) {
   DCHECK(CalledOnValidThread());
   return cricket_session_ == cricket_session;
 }
 
 cricket::Session* JingleSession::ReleaseSession() {
   DCHECK(CalledOnValidThread());
@@ skipping 110 matching lines @@
 
 const std::string& JingleSession::shared_secret() {
   DCHECK(CalledOnValidThread());
   return shared_secret_;
 }
 
 
 void JingleSession::Close() {
   DCHECK(CalledOnValidThread());
 
-  CloseInternal(net::ERR_CONNECTION_CLOSED, false);
+  CloseInternal(net::ERR_CONNECTION_CLOSED, OK);
 }
 
 void JingleSession::OnSessionState(
     BaseSession* session, BaseSession::State state) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(cricket_session_, session);
 
   if (state_ == FAILED || state_ == CLOSED) {
     // Don't do anything if we already closed.
     return;
@@ skipping 27 matching lines @@
       break;
   }
 }
 
 void JingleSession::OnSessionError(
     BaseSession* session, BaseSession::Error error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(cricket_session_, session);
 
   if (error != cricket::Session::ERROR_NONE) {
-    CloseInternal(net::ERR_CONNECTION_ABORTED, true);
+    // TODO(sergeyu): Report different errors depending on |error|.
+    CloseInternal(net::ERR_CONNECTION_ABORTED, CHANNEL_CONNECTION_ERROR);
   }
 }
 
 void JingleSession::OnInitiate() {
   DCHECK(CalledOnValidThread());
   jid_ = cricket_session_->remote_name();
 
   if (!cricket_session_->initiator()) {
     const protocol::ContentDescription* content_description =
         static_cast<const protocol::ContentDescription*>(
@@ skipping 52 matching lines @@
 }
 
 void JingleSession::OnAccept() {
   DCHECK(CalledOnValidThread());
 
   // If we initiated the session, store the candidate configuration that the
   // host responded with, to refer to later.
   if (cricket_session_->initiator()) {
     if (!InitializeConfigFromDescription(
             cricket_session_->remote_description())) {
-      CloseInternal(net::ERR_CONNECTION_FAILED, true);
+      CloseInternal(net::ERR_CONNECTION_FAILED, INCOMPATIBLE_PROTOCOL);
       return;
     }
   }
 
   CreateChannels();
 
   SetState(CONNECTED);
 }
 
 void JingleSession::OnTerminate() {
   DCHECK(CalledOnValidThread());
-  CloseInternal(net::ERR_CONNECTION_ABORTED, false);
+  CloseInternal(net::ERR_CONNECTION_ABORTED, OK);
 }
 
 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();
@@ skipping 44 matching lines @@
       base::Bind(&JingleSession::OnChannelConnected,
                  base::Unretained(this), &event_channel_socket_));
 }
 
 void JingleSession::OnChannelConnected(
     scoped_ptr<net::Socket>* socket_container,
     net::StreamSocket* socket) {
   if (!socket) {
     LOG(ERROR) << "Failed to connect control or events channel. "
                << "Terminating connection";
-    CloseInternal(net::ERR_CONNECTION_CLOSED, true);
+    CloseInternal(net::ERR_CONNECTION_CLOSED, CHANNEL_CONNECTION_ERROR);
     return;
   }
 
   socket_container->reset(socket);
 
   if (control_channel_socket_.get() && event_channel_socket_.get())
     SetState(CONNECTED_CHANNELS);
 }
 
 const cricket::ContentInfo* JingleSession::GetContentInfo() const {
@@ skipping 19 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