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

remoting/protocol/negotiating_authenticator.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/negotiating_authenticator.h"
 
 #include <algorithm>
 #include <sstream>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "crypto/rsa_private_key.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/v2_authenticator.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 namespace remoting {
 namespace protocol {
 
@@ skipping 63 matching lines @@
 
 Authenticator::State NegotiatingAuthenticator::state() const {
   return state_;
 }
 
 Authenticator::RejectionReason
 NegotiatingAuthenticator::rejection_reason() const {
   return rejection_reason_;
 }
 
-void NegotiatingAuthenticator::ProcessMessage(const buzz::XmlElement* message) {
+void NegotiatingAuthenticator::ProcessMessage(
+    const buzz::XmlElement* message,
+    const base::Closure& resume_callback) {
   DCHECK_EQ(state(), WAITING_MESSAGE);
 
   std::string method_attr = message->Attr(kMethodAttributeQName);
   AuthenticationMethod method = AuthenticationMethod::FromString(method_attr);
 
   // Check if the remote end specified a method that is not supported locally.
   if (method.is_valid() &&
       std::find(methods_.begin(), methods_.end(), method) == methods_.end()) {
     method = AuthenticationMethod::Invalid();
   }
 
   // If the remote peer did not specify auth method or specified unknown
   // method then select the first known method from the supported-methods
   // attribute.
   if (!method.is_valid()) {
     std::string supported_methods_attr =
         message->Attr(kSupportedMethodsAttributeQName);
     if (supported_methods_attr.empty()) {
       // Message contains neither method nor supported-methods attributes.
       state_ = REJECTED;
       rejection_reason_ = PROTOCOL_ERROR;
+      resume_callback.Run();
       return;
     }
 
     // Find the first mutually-supported method in the peer's list of
     // supported-methods.
     std::vector<std::string> supported_methods_strs;
     base::SplitString(supported_methods_attr, kSupportedMethodsSeparator,
                       &supported_methods_strs);
     for (std::vector<std::string>::iterator it = supported_methods_strs.begin();
          it != supported_methods_strs.end(); ++it) {
       AuthenticationMethod list_value = AuthenticationMethod::FromString(*it);
       if (list_value.is_valid() &&
           std::find(methods_.begin(),
                     methods_.end(), list_value) != methods_.end()) {
         // Found common method.
         method = list_value;
         break;
       }
     }
 
     if (!method.is_valid()) {
       // Failed to find a common auth method.
       state_ = REJECTED;
       rejection_reason_ = PROTOCOL_ERROR;
+      resume_callback.Run();
       return;
     }
 
     // Drop the current message because we've chosen a different
     // method.
     state_ = MESSAGE_READY;
   }
 
   DCHECK(method.is_valid());
 
   // Replace current authenticator if the method has changed.
   if (method != current_method_) {
     current_method_ = method;
     CreateAuthenticator(state_);
   }
+  if (state_ == WAITING_MESSAGE) {
+    // |current_authenticator_| is owned, so Unretained() is safe here.
+    current_authenticator_->ProcessMessage(message, base::Bind(
+        &NegotiatingAuthenticator::UpdateState,
+        base::Unretained(this), resume_callback));
+  } else {
+    UpdateState(resume_callback);
+  }
+}
 
-  if (state_ == WAITING_MESSAGE) {
-    current_authenticator_->ProcessMessage(message);
-    state_ = current_authenticator_->state();
-    if (state_ == REJECTED)
-      rejection_reason_ = current_authenticator_->rejection_reason();
-  }
+void NegotiatingAuthenticator::UpdateState(
+    const base::Closure& resume_callback) {
+  // After the underlying authenticator finishes processing the message, the
+  // NegotiatingAuthenticator must update its own state before running the
+  // |resume_callback| to resume the session negotiation.
+  state_ = current_authenticator_->state();
+  if (state_ == REJECTED)
+    rejection_reason_ = current_authenticator_->rejection_reason();
+  resume_callback.Run();
 }
 
 scoped_ptr<buzz::XmlElement> NegotiatingAuthenticator::GetNextMessage() {
   DCHECK_EQ(state(), MESSAGE_READY);
 
   bool add_supported_methods_attr = false;
 
   // Initialize current method in case it is not initialized
   // yet. Normally happens only on client.
   if (!current_method_.is_valid()) {
@@ skipping 50 matching lines @@
     current_authenticator_ = V2Authenticator::CreateForClient(
         AuthenticationMethod::ApplyHashFunction(
             current_method_.hash_function(),
             authentication_tag_, shared_secret_),
         initial_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting