[Draft] Fix canceling pin prompt causes host overload

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/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/channel_multiplexer.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/session_config.h"
@@ skipping 35 matching lines @@
   return UNKNOWN_ERROR;
 }
 
 }  // namespace
 
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       event_handler_(NULL),
       state_(INITIALIZING),
       error_(OK),
-      config_is_set_(false) {
+      config_is_set_(false),
+      weak_factory_(this) {
 }
 
 JingleSession::~JingleSession() {
   channel_multiplexer_.reset();
   STLDeleteContainerPointers(pending_requests_.begin(),
                              pending_requests_.end());
   STLDeleteContainerPointers(transport_info_requests_.begin(),
                              transport_info_requests_.end());
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   session_manager_->SessionDestroyed(this);
@@ skipping 97 matching lines @@
                              auth_message.Pass()));
   SendMessage(message);
 
   // Update state.
   SetState(CONNECTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     SetState(AUTHENTICATED);
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
+    if (authenticator_->started()) {
+      SetState(AUTHENTICATING);
+    }
   }
-
-  return;
 }
 
 const std::string& JingleSession::jid() {
   DCHECK(CalledOnValidThread());
   return peer_jid_;
 }
 
 const CandidateSessionConfig* JingleSession::candidate_config() {
   DCHECK(CalledOnValidThread());
   return candidate_config_.get();
@@ skipping 281 matching lines @@
 }
 
 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 ||
+  if ((state_ != CONNECTED && state_ != AUTHENTICATING) ||
       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);
 
@@ skipping 11 matching lines @@
     } else {
       // Transport info was received before the channel was created.
       // This could happen due to messages being reordered on the wire.
       pending_remote_candidates_.push_back(*it);
     }
   }
 }
 
 void JingleSession::OnTerminate(const JingleMessage& message,
                                 const ReplyCallback& reply_callback) {
-  if (state_ != CONNECTING && state_ != ACCEPTING && state_ != CONNECTED &&
-      state_ != AUTHENTICATED) {
+  if (!is_session_active()) {
     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 38 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void JingleSession::ProcessAuthenticationStep() {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(authenticator_->state(), Authenticator::PROCESSING_MESSAGE);
 
-  if (state_ != CONNECTED) {
+  if (state_ != CONNECTED && state_ != AUTHENTICATING) {
     DCHECK(state_ == FAILED || state_ == CLOSED);
     // The remote host closed the connection while the authentication was being
     // processed asynchronously, nothing to do.
     return;
   }
 
   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);
 
+  // The current JingleSession object can be destroyed by event_handler of
+  // SetState(AUTHENTICATING) and cause subsequent dereferencing of the this
+  // pointer to crash.  To protect against it, we run ContinueAuthenticationStep
+  // asychronously using a weak pointer.
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+    FROM_HERE,
+    base::Bind(&JingleSession::ContinueAuthenticationStep,
+               weak_factory_.GetWeakPtr()));
+
+  if (authenticator_->started()) {
+    SetState(AUTHENTICATING);
+  }
+}
+
+void JingleSession::ContinueAuthenticationStep() {
   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_ == ACCEPTING || state_ == CONNECTED ||
-      state_ == AUTHENTICATED) {
+  if (is_session_active()) {
     // 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 30 matching lines @@
   if (new_state != state_) {
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (event_handler_)
       event_handler_->OnSessionStateChange(new_state);
   }
 }
 
+bool JingleSession::is_session_active() {
+  return state_ == CONNECTING || state_ == ACCEPTING || state_ == CONNECTED ||
+        state_ == AUTHENTICATING || state_ == AUTHENTICATED;
+}
+
 }  // namespace protocol
 }  // namespace remoting