Refactor of Authenticator to allow it to ProcessMessage asynchronously and then call a callback

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 112 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
 
   peer_jid_ = initiate_message.from;
   authenticator_ = authenticator.Pass();
   session_id_ = initiate_message.sid;
   candidate_config_ = initiate_message.description->config()->Clone();
 
-  SetState(CONNECTING);
+  SetState(ACCEPTING);
 }
 
 void JingleSession::AcceptIncomingConnection(
     const JingleMessage& initiate_message) {
   DCHECK(config_is_set_);
 
   // Process the first authentication message.
   const buzz::XmlElement* first_auth_message =
       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);
+  // |this| outlives authenticator_, so using Unretained is safe here.
+  authenticator_->ProcessMessage(
+      base::Bind(&JingleSession::ContinueAcceptIncomingConnection,
+                 base::Unretained(this)),
+      first_auth_message);
+}
+
+void JingleSession::ContinueAcceptIncomingConnection() {
+  DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
   if (authenticator_->state() == Authenticator::REJECTED) {
     CloseInternal(AuthRejectionReasonToErrorCode(
         authenticator_->rejection_reason()));
     return;
   }
 
   // Send the session-accept message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
@@ skipping 267 matching lines @@
 
   const buzz::XmlElement* auth_message =
       message.description->authenticator_message();
   if (!auth_message) {
     DLOG(WARNING) << "Received session-accept without authentication message "
                   << auth_message->Str();
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
-  DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
-  authenticator_->ProcessMessage(auth_message);
-
   if (!InitializeConfigFromDescription(message.description.get())) {
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   // In case there is transport information in the accept message.
   ProcessTransportInfo(message);
 
   SetState(CONNECTED);
 
-  // Process authentication.
-  if (authenticator_->state() == Authenticator::ACCEPTED) {
-    SetState(AUTHENTICATED);
-  } else {
-    ProcessAuthenticationStep();
-  }
+  DCHECK(authenticator_->state() == Authenticator::WAITING_MESSAGE);
+  authenticator_->ProcessMessage(
+      base::Bind(&JingleSession::ProcessAuthenticationStep,
+                 base::Unretained(this)),
+      auth_message);
 }
 
 void JingleSession::OnSessionInfo(const JingleMessage& message,
                                   const ReplyCallback& reply_callback) {
   if (!message.info.get() ||
       !Authenticator::IsAuthenticatorMessage(message.info.get())) {
     reply_callback.Run(JingleMessageReply::UNSUPPORTED_INFO);
     return;
   }
 
   if (state_ != CONNECTED ||
       authenticator_->state() != Authenticator::WAITING_MESSAGE) {
     LOG(WARNING) << "Received unexpected authenticator message "
                  << message.info->Str();
     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
     CloseInternal(INCOMPATIBLE_PROTOCOL);
     return;
   }
 
   reply_callback.Run(JingleMessageReply::NONE);
 
-  authenticator_->ProcessMessage(message.info.get());
-  ProcessAuthenticationStep();
+  authenticator_->ProcessMessage(
+      base::Bind(&JingleSession::ProcessAuthenticationStep,
+                 base::Unretained(this)),
+      message.info.get());
 }
 
 void JingleSession::ProcessTransportInfo(const JingleMessage& message) {
   for (std::list<JingleMessage::NamedCandidate>::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->AddRemoteCandidate(it->candidate);
   }
 }
 
 void JingleSession::OnTerminate(const JingleMessage& message,
                                 const ReplyCallback& reply_callback) {
-  if (state_ != CONNECTING && state_ != CONNECTED && state_ != AUTHENTICATED) {
+  if (state_ != CONNECTING && state_ != ACCEPTING && state_ != CONNECTED &&
+      state_ != AUTHENTICATED) {
     LOG(WARNING) << "Received unexpected session-terminate message.";
     reply_callback.Run(JingleMessageReply::UNEXPECTED_REQUEST);
     return;
   }
 
   reply_callback.Run(JingleMessageReply::NONE);
 
   switch (message.reason) {
     case JingleMessage::SUCCESS:
       if (state_ == CONNECTING) {
@@ skipping 35 matching lines @@
   }
   if (!candidate_config()->IsSupported(config_)) {
     LOG(ERROR) << "session-accept specifies an invalid configuration";
     return false;
   }
 
   return true;
 }
 
 void JingleSession::ProcessAuthenticationStep() {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, CONNECTED);
+  DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
 
   if (authenticator_->state() == Authenticator::MESSAGE_READY) {
     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(AuthRejectionReasonToErrorCode(
         authenticator_->rejection_reason()));
   }
 }
 
 void JingleSession::CloseInternal(ErrorCode error) {
   DCHECK(CalledOnValidThread());
 
-  if (state_ == CONNECTING || state_ == CONNECTED || state_ == AUTHENTICATED) {
+  if (state_ == CONNECTING || state_ == ACCEPTING || 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:
       case AUTHENTICATION_FAILED:
         reason = JingleMessage::DECLINE;
         break;
@@ skipping 32 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (event_handler_)
       event_handler_->OnSessionStateChange(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting