Separate Authenticator and Session unittests.

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/base64.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
@@ skipping 27 matching lines @@
       authenticator_(authenticator),
       state_(INITIALIZING),
       error_(OK),
       closing_(false),
       cricket_session_(cricket_session),
       config_set_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
   jid_ = cricket_session_->remote_name();
   cricket_session_->SignalState.connect(this, &JingleSession::OnSessionState);
   cricket_session_->SignalError.connect(this, &JingleSession::OnSessionError);
+  cricket_session_->SignalReceivedTerminateReason.connect(
+      this, &JingleSession::OnTerminateReason);
 }
 
 JingleSession::~JingleSession() {
   // Reset the callback so that it's not called from Close().
   state_change_callback_.Reset();
   Close();
   jingle_session_manager_->SessionDestroyed(this);
   DCHECK(channel_connectors_.empty());
 }
 
@@ skipping 179 matching lines @@
     BaseSession* session, BaseSession::Error error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(cricket_session_, session);
 
   if (error != cricket::Session::ERROR_NONE) {
     // TODO(sergeyu): Report different errors depending on |error|.
     CloseInternal(net::ERR_CONNECTION_ABORTED, CHANNEL_CONNECTION_ERROR);
   }
 }
 
+void JingleSession::OnTerminateReason(cricket::Session* session,
+                                      const std::string& reason) {
+  terminate_reason_ = reason;
+}
+
 void JingleSession::OnInitiate() {
   DCHECK(CalledOnValidThread());
   jid_ = cricket_session_->remote_name();
 
   if (cricket_session_->initiator()) {
     // Set state to CONNECTING if this is an outgoing message. We need
     // to post this task because channel creation works only after we
     // return from this method. This is because
     // JingleChannelConnector::Connect() needs to call
     // set_incoming_only() on P2PTransportChannel, but
@@ skipping 68 matching lines @@
   }
 
   SetState(CONNECTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED)
     SetState(AUTHENTICATED);
 }
 
 void JingleSession::OnTerminate() {
   DCHECK(CalledOnValidThread());
-  CloseInternal(net::ERR_CONNECTION_ABORTED, OK);
+
+  if (terminate_reason_ == "success") {
+    CloseInternal(net::ERR_CONNECTION_ABORTED, OK);
+  } else if (terminate_reason_ == "decline") {
+    CloseInternal(net::ERR_CONNECTION_ABORTED, AUTHENTICATION_FAILED);
+  } else if (terminate_reason_ == "incompatible-protocol") {
+    CloseInternal(net::ERR_CONNECTION_ABORTED, INCOMPATIBLE_PROTOCOL);
+  } else {
+    CloseInternal(net::ERR_CONNECTION_ABORTED, UNKNOWN_ERROR);
+  }
 }
 
 void JingleSession::AcceptConnection() {
   SetState(CONNECTING);
 
   const cricket::SessionDescription* session_description =
       cricket_session_->remote_description();
   const cricket::ContentInfo* content =
       session_description->FirstContentByType(kChromotingXmlNamespace);
 
@@ skipping 122 matching lines @@
     const buzz::XmlElement* authenticator_message) {
   cricket::SessionDescription* desc = new cricket::SessionDescription();
   desc->AddContent(
       ContentDescription::kChromotingContentName, kChromotingXmlNamespace,
       new ContentDescription(config, authenticator_message));
   return desc;
 }
 
 }  // namespace protocol
 }  // namespace remoting