Refactor IqRequest.

remoting/host/register_support_host_request.cc

 // Copyright (c) 2011 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/host/register_support_host_request.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/host_config.h"
-#include "remoting/jingle_glue/iq_request.h"
+#include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/jingle_glue/jingle_thread.h"
 #include "remoting/jingle_glue/signal_strategy.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 #include "third_party/libjingle/source/talk/xmpp/constants.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 
@@ skipping 27 matching lines @@
   return true;
 }
 
 void RegisterSupportHostRequest::OnSignallingConnected(
     SignalStrategy* signal_strategy,
     const std::string& jid) {
   DCHECK(!callback_.is_null());
 
   message_loop_ = MessageLoop::current();
 
-  request_.reset(signal_strategy->CreateIqRequest());
-  request_->set_callback(base::Bind(
-      &RegisterSupportHostRequest::ProcessResponse, base::Unretained(this)));
-
-  request_->SendIq(IqRequest::MakeIqStanza(
-      buzz::STR_SET, kChromotingBotJid, CreateRegistrationRequest(jid)));
+  iq_sender_.reset(new IqSender(signal_strategy));
+  request_.reset(iq_sender_->SendIq(
+      buzz::STR_SET, kChromotingBotJid, CreateRegistrationRequest(jid),
+      base::Bind(&RegisterSupportHostRequest::ProcessResponse,
+                 base::Unretained(this))));
 }
 
 void RegisterSupportHostRequest::OnSignallingDisconnected() {
   if (!message_loop_) {
     // We will reach here with |message_loop_| NULL if the Host's
     // XMPP connection attempt fails.
     CHECK(!callback_.is_null());
     DCHECK(!request_.get());
     callback_.Run(false, std::string(), base::TimeDelta());
     return;
   }
   DCHECK_EQ(message_loop_, MessageLoop::current());
   request_.reset();
+  iq_sender_.reset();
 }
 
 // Ignore any notifications other than signalling
 // connected/disconnected events.
 void RegisterSupportHostRequest::OnAccessDenied() { }
 void RegisterSupportHostRequest::OnClientAuthenticated(
     const std::string& jid) { }
 void RegisterSupportHostRequest::OnClientDisconnected(
     const std::string& jid) { }
 void RegisterSupportHostRequest::OnShutdown() { }
@@ skipping 31 matching lines @@
                                                std::string* support_id,
                                                base::TimeDelta* lifetime) {
   std::string type = response->Attr(buzz::QN_TYPE);
   if (type == buzz::STR_ERROR) {
     LOG(ERROR) << "Received error in response to heartbeat: "
                << response->Str();
     return false;
   }
 
   // This method must only be called for error or result stanzas.
-  DCHECK_EQ(std::string(buzz::STR_RESULT), type);
+  if (type != buzz::STR_RESULT) {
+    LOG(ERROR) << "Received unexpect stanza of type \"" << type << "\"";
+    return false;
+  }
 
   const XmlElement* result_element = response->FirstNamed(QName(
       kChromotingXmlNamespace, kRegisterQueryResultTag));
   if (!result_element) {
     LOG(ERROR) << "<" << kRegisterQueryResultTag
                << "> is missing in the host registration response: "
                << response->Str();
     return false;
   }
 
@@ skipping 33 matching lines @@
 
 void RegisterSupportHostRequest::ProcessResponse(const XmlElement* response) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   std::string support_id;
   base::TimeDelta lifetime;
   bool success = ParseResponse(response, &support_id, &lifetime);
   callback_.Run(success, support_id, lifetime);
 }
 
 }  // namespace remoting