[Draft] Fix canceling pin prompt causes host overload

remoting/protocol/v2_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/v2_authenticator.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/rsa_key_pair.h"
@@ skipping 44 matching lines @@
   return scoped_ptr<Authenticator>(result.Pass());
 }
 
 V2Authenticator::V2Authenticator(
     crypto::P224EncryptedKeyExchange::PeerType type,
     const std::string& shared_secret,
     Authenticator::State initial_state)
     : certificate_sent_(false),
       key_exchange_impl_(type, shared_secret),
       state_(initial_state),
+      started_(false),
       rejection_reason_(INVALID_CREDENTIALS) {
   pending_messages_.push(key_exchange_impl_.GetMessage());
 }
 
 V2Authenticator::~V2Authenticator() {
 }
 
 Authenticator::State V2Authenticator::state() const {
   if (state_ == ACCEPTED && !pending_messages_.empty())
     return MESSAGE_READY;
   return state_;
 }
 
+bool V2Authenticator::started() const {
+  return started_;
+}
+
 Authenticator::RejectionReason V2Authenticator::rejection_reason() const {
   DCHECK_EQ(state(), REJECTED);
   return rejection_reason_;
 }
 
 void V2Authenticator::ProcessMessage(const buzz::XmlElement* message,
                                      const base::Closure& resume_callback) {
   ProcessMessageInternal(message);
   resume_callback.Run();
 }
@@ skipping 32 matching lines @@
     if (base64_message.empty() ||
         !base::Base64Decode(base64_message, &spake_message)) {
       LOG(WARNING) << "Failed to decode auth message received from the peer.";
       state_ = REJECTED;
       rejection_reason_ = PROTOCOL_ERROR;
       return;
     }
 
     P224EncryptedKeyExchange::Result result =
         key_exchange_impl_.ProcessMessage(spake_message);
+    started_ = true;
     switch (result) {
       case P224EncryptedKeyExchange::kResultPending:
         pending_messages_.push(key_exchange_impl_.GetMessage());
         break;
 
       case P224EncryptedKeyExchange::kResultFailed:
         state_ = REJECTED;
         rejection_reason_ = INVALID_CREDENTIALS;
         return;
 
       case P224EncryptedKeyExchange::kResultSuccess:
         auth_key_ = key_exchange_impl_.GetKey();
         state_ = ACCEPTED;
         return;
     }
   }
-
   state_ = MESSAGE_READY;
 }
 
 scoped_ptr<buzz::XmlElement> V2Authenticator::GetNextMessage() {
   DCHECK_EQ(state(), MESSAGE_READY);
 
   scoped_ptr<buzz::XmlElement> message = CreateEmptyAuthenticatorMessage();
 
   DCHECK(!pending_messages_.empty());
   while (!pending_messages_.empty()) {
@@ skipping 38 matching lines @@
             remote_cert_, auth_key_).Pass());
   }
 }
 
 bool V2Authenticator::is_host_side() const {
   return local_key_pair_.get() != NULL;
 }
 
 }  // namespace protocol
 }  // namespace remoting