Revert 123635 - Implement timeouts for IQ requests.

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 14 matching lines @@
 namespace protocol {
 
 namespace {
 // Delay after candidate creation before sending transport-info
 // message. This is neccessary to be able to pack multiple candidates
 // into one transport-info messages. The value needs to be greater
 // than zero because ports are opened asynchronously in the browser
 // process.
 const int kTransportInfoSendDelayMs = 2;
 
-// How long we should wait for a response from the other end. This
-// value is used for all requests include |session-initiate| and
-// |transport-info|.
-const int kMessageResponseTimeoutSeconds = 10;
-
 Session::Error AuthRejectionReasonToError(
     Authenticator::RejectionReason reason) {
   switch (reason) {
     case Authenticator::INVALID_CREDENTIALS:
       return Session::AUTHENTICATION_FAILED;
     case Authenticator::PROTOCOL_ERROR:
       return Session::INCOMPATIBLE_PROTOCOL;
   }
   NOTREACHED();
   return Session::UNKNOWN_ERROR;
 }
 
 }  // namespace
 
 JingleSession::JingleSession(JingleSessionManager* session_manager)
     : session_manager_(session_manager),
       state_(INITIALIZING),
       error_(OK),
       config_is_set_(false) {
 }
 
 JingleSession::~JingleSession() {
-  STLDeleteContainerPointers(pending_requests_.begin(),
-                             pending_requests_.end());
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   session_manager_->SessionDestroyed(this);
 }
 
 void JingleSession::SetStateChangeCallback(
     const StateChangeCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
   state_change_callback_ = callback;
 }
@@ skipping 28 matching lines @@
   // enough entropy. In the worst case connection will fail when two
   // clients generate the same session ID concurrently.
   session_id_ = base::Int64ToString(base::RandGenerator(kint64max));
 
   // Send session-initiate message.
   JingleMessage message(peer_jid_, JingleMessage::SESSION_INITIATE,
                         session_id_);
   message.description.reset(
       new ContentDescription(candidate_config_->Clone(),
                              authenticator_->GetNextMessage()));
-  SendMessage(message);
+  initiate_request_ = session_manager_->iq_sender()->SendIq(
+      message.ToXml(),
+      base::Bind(&JingleSession::OnSessionInitiateResponse,
+                 base::Unretained(this)));
 
   SetState(CONNECTING);
 }
 
 void JingleSession::InitializeIncomingConnection(
     const JingleMessage& initiate_message,
     scoped_ptr<Authenticator> authenticator) {
   DCHECK(CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
@@ skipping 32 matching lines @@
   JingleMessage message(peer_jid_, JingleMessage::SESSION_ACCEPT,
                         session_id_);
 
   scoped_ptr<buzz::XmlElement> auth_message;
   if (authenticator_->state() == Authenticator::MESSAGE_READY)
     auth_message = authenticator_->GetNextMessage();
 
   message.description.reset(
       new ContentDescription(CandidateSessionConfig::CreateFrom(config_),
                              auth_message.Pass()));
-  SendMessage(message);
+  initiate_request_ = session_manager_->iq_sender()->SendIq(
+      message.ToXml(),
+      base::Bind(&JingleSession::OnSessionInitiateResponse,
+                 base::Unretained(this)));
 
   // Update state.
   SetState(CONNECTED);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     SetState(AUTHENTICATED);
   } else {
     DCHECK_EQ(authenticator_->state(), Authenticator::WAITING_MESSAGE);
   }
 
   return;
 }
 
+void JingleSession::OnSessionInitiateResponse(
+    const buzz::XmlElement* response) {
+  const std::string& type = response->Attr(buzz::QName("", "type"));
+  if (type != "result") {
+    LOG(ERROR) << "Received error in response to session-initiate message: \""
+               << response->Str()
+               << "\". Terminating the session.";
+
+    // TODO(sergeyu): There may be different reasons for error
+    // here. Parse the response stanza to find failure reason.
+    CloseInternal(PEER_IS_OFFLINE);
+  }
+}
+
 void JingleSession::CreateStreamChannel(
       const std::string& name,
       const StreamChannelCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<ChannelAuthenticator> channel_authenticator =
       authenticator_->CreateChannelAuthenticator();
   scoped_ptr<StreamTransport> channel =
       session_manager_->transport_factory_->CreateStreamTransport();
   channel->Initialize(name, session_manager_->transport_config_,
@@ skipping 73 matching lines @@
                                route.local_address);
   }
 }
 
 void JingleSession::OnTransportDeleted(Transport* transport) {
   ChannelsMap::iterator it = channels_.find(transport->name());
   DCHECK_EQ(it->second, transport);
   channels_.erase(it);
 }
 
-void JingleSession::SendMessage(const JingleMessage& message) {
-  scoped_ptr<IqRequest> request = session_manager_->iq_sender()->SendIq(
-      message.ToXml(),
-      base::Bind(&JingleSession::OnMessageResponse,
-                 base::Unretained(this), message.action));
-  if (request.get()) {
-    request->SetTimeout(
-        base::TimeDelta::FromSeconds(kMessageResponseTimeoutSeconds));
-    pending_requests_.push_back(request.release());
-  } else {
-    LOG(ERROR) << "Failed to send a "
-               << JingleMessage::GetActionName(message.action) << " message";
-  }
-}
-
-void JingleSession::OnMessageResponse(
-    JingleMessage::ActionType request_type,
-    IqRequest* request,
-    const buzz::XmlElement* response) {
-  Error error = OK;
-
-  std::string type_str = JingleMessage::GetActionName(request_type);
-
-  if (!response) {
-    LOG(ERROR) << type_str << " request timed out.";
-    // Most likely the session-initiate timeout indicates a problem
-    // with the signaling.
-    error = UNKNOWN_ERROR;
-  } else {
-    const std::string& type = response->Attr(buzz::QName("", "type"));
-    if (type != "result") {
-      LOG(ERROR) << "Received error in response to " << type_str
-                 << " message: \"" << response->Str()
-                 << "\". Terminating the session.";
-
-      switch (request_type) {
-        case JingleMessage::SESSION_INFO:
-          // session-info is used for the new authentication protocol,
-          // and wasn't previously supported.
-          error = INCOMPATIBLE_PROTOCOL;
-
-        default:
-          // TODO(sergeyu): There may be different reasons for error
-          // here. Parse the response stanza to find failure reason.
-          error = PEER_IS_OFFLINE;
-      }
-    }
-  }
-
-  CleanupPendingRequests(request);
-
-  if (error != OK) {
-    CloseInternal(error);
-  }
-}
-
-void JingleSession::CleanupPendingRequests(IqRequest* request) {
-  DCHECK(!pending_requests_.empty());
-  DCHECK(request);
-
-  // This method is called whenever a response to |request| is
-  // received. Here we delete that request and all requests that were
-  // sent before it. The idea here is that if we send messages A, B
-  // and C and then suddenly receive response to C then it means that
-  // either A and B messages or the corresponding response messages
-  // were somehow lost. E.g. that may happen when the client switches
-  // from one network to another. The best way to handle that case is
-  // to ignore errors and timeouts for A and B by deleting the
-  // corresponding IqRequest objects.
-  while (!pending_requests_.empty() && pending_requests_.front() != request) {
-    delete pending_requests_.front();
-    pending_requests_.pop_front();
-  }
-
-  // Delete the |request| itself.
-  DCHECK_EQ(request, pending_requests_.front());
-  delete request;
-  if (!pending_requests_.empty())
-    pending_requests_.pop_front();
-}
-
 void JingleSession::OnIncomingMessage(const JingleMessage& message,
                                       const ReplyCallback& reply_callback) {
   DCHECK(CalledOnValidThread());
 
   if (message.from != peer_jid_) {
     // Ignore messages received from a different Jid.
     reply_callback.Run(JingleMessageReply::INVALID_SID);
     return;
   }
 
@@ skipping 149 matching lines @@
   return true;
 }
 
 void JingleSession::ProcessAuthenticationStep() {
   DCHECK_EQ(state_, CONNECTED);
 
   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);
+
+    session_info_request_ = session_manager_->iq_sender()->SendIq(
+        message.ToXml(), base::Bind(
+            &JingleSession::OnSessionInfoResponse,
+            base::Unretained(this)));
   }
   DCHECK_NE(authenticator_->state(), Authenticator::MESSAGE_READY);
 
   if (authenticator_->state() == Authenticator::ACCEPTED) {
     SetState(AUTHENTICATED);
   } else if (authenticator_->state() == Authenticator::REJECTED) {
     CloseInternal(AuthRejectionReasonToError(
         authenticator_->rejection_reason()));
   }
 }
 
+void JingleSession::OnSessionInfoResponse(const buzz::XmlElement* response) {
+  const std::string& type = response->Attr(buzz::QName("", "type"));
+  if (type != "result") {
+    LOG(ERROR) << "Received error in response to session-info message: \""
+               << response->Str()
+               << "\". Terminating the session.";
+    CloseInternal(INCOMPATIBLE_PROTOCOL);
+  }
+}
+
+void JingleSession::OnTransportInfoResponse(const buzz::XmlElement* response) {
+  const std::string& type = response->Attr(buzz::QName("", "type"));
+  if (type != "result") {
+    LOG(ERROR) << "Received error in response to session-initiate message: \""
+               << response->Str()
+               << "\". Terminating the session.";
+
+    if (state_ == CONNECTING) {
+      CloseInternal(PEER_IS_OFFLINE);
+    } else {
+      // Host has disconnected without sending session-terminate message.
+      CloseInternal(OK);
+    }
+  }
+}
+
 void JingleSession::SendTransportInfo() {
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.candidates.swap(pending_candidates_);
-  SendMessage(message);
+  transport_info_request_ = session_manager_->iq_sender()->SendIq(
+      message.ToXml(), base::Bind(
+          &JingleSession::OnTransportInfoResponse,
+          base::Unretained(this)));
 }
 
+
 void JingleSession::CloseInternal(Error error) {
   DCHECK(CalledOnValidThread());
 
   if (state_ == CONNECTING || 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;
       case INCOMPATIBLE_PROTOCOL:
         reason = JingleMessage::INCOMPATIBLE_PARAMETERS;
         break;
       default:
         reason = JingleMessage::GENERAL_ERROR;
     }
 
     JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
                           session_id_);
     message.reason = reason;
-    SendMessage(message);
+    session_manager_->iq_sender()->SendIq(
+        message.ToXml(), IqSender::ReplyCallback());
   }
 
   error_ = error;
 
   if (state_ != FAILED && state_ != CLOSED) {
     if (error != OK) {
       SetState(FAILED);
     } else {
       SetState(CLOSED);
     }
   }
 }
 
 void JingleSession::SetState(State new_state) {
   DCHECK(CalledOnValidThread());
 
   if (new_state != state_) {
     DCHECK_NE(state_, CLOSED);
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting