Refactor IqRequest.

remoting/protocol/pepper_session.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/protocol/pepper_session.h"
 
 #include "base/bind.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
-#include "remoting/jingle_glue/iq_request.h"
+#include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/protocol/content_description.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/pepper_session_manager.h"
 #include "remoting/protocol/pepper_stream_channel.h"
 #include "third_party/libjingle/source/talk/p2p/base/candidate.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
@@ skipping 51 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.from = session_manager_->local_jid_;
   message.description.reset(
       new ContentDescription(candidate_config_->Clone(), initiator_token_, ""));
-  initiate_request_.reset(session_manager_->CreateIqRequest());
-  initiate_request_->set_callback(base::Bind(
-      &PepperSession::OnSessionInitiateResponse, base::Unretained(this)));
-  initiate_request_->SendIq(message.ToXml());
+  initiate_request_.reset(session_manager_->iq_sender()->SendIq(
+      message.ToXml(),
+      base::Bind(&PepperSession::OnSessionInitiateResponse,
+                 base::Unretained(this))));
 
   SetState(CONNECTING);
 }
 
 void PepperSession::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()
@@ skipping 91 matching lines @@
 }
 
 void PepperSession::Close() {
   DCHECK(CalledOnValidThread());
 
   if (state_ == CONNECTING || state_ == CONNECTED ||
       state_ == CONNECTED_CHANNELS) {
     // Send session-terminate message.
     JingleMessage message(peer_jid_, JingleMessage::SESSION_TERMINATE,
                           session_id_);
-    scoped_ptr<IqRequest>  terminate_request(
-        session_manager_->CreateIqRequest());
-    terminate_request->SendIq(message.ToXml());
+    scoped_ptr<IqRequest> terminate_request(
+        session_manager_->iq_sender()->SendIq(
+            message.ToXml(), IqSender::ReplyCallback()));
   }
 
   CloseInternal(false);
 }
 
 void PepperSession::OnIncomingMessage(const JingleMessage& message,
                                       JingleMessageReply* reply) {
   DCHECK(CalledOnValidThread());
 
   if (message.from != peer_jid_) {
@@ skipping 111 matching lines @@
 
 void PepperSession::OnDeleteChannel(PepperChannel* channel) {
   ChannelsMap::iterator it = channels_.find(channel->name());
   DCHECK_EQ(it->second, channel);
   channels_.erase(it);
 }
 
 void PepperSession::SendTransportInfo() {
   JingleMessage message(peer_jid_, JingleMessage::TRANSPORT_INFO, session_id_);
   message.candidates.swap(pending_candidates_);
-  scoped_ptr<IqRequest> request(session_manager_->CreateIqRequest());
-  request->SendIq(message.ToXml());
+  scoped_ptr<IqRequest> request(session_manager_->iq_sender()->SendIq(
+      message.ToXml(), IqSender::ReplyCallback()));
 }
 
 void PepperSession::CreateChannels() {
    CreateStreamChannel(
       kControlChannelName,
       base::Bind(&PepperSession::OnChannelConnected,
                  base::Unretained(this), &control_channel_socket_));
   CreateStreamChannel(
       kEventChannelName,
       base::Bind(&PepperSession::OnChannelConnected,
@@ skipping 38 matching lines @@
     DCHECK_NE(state_, FAILED);
 
     state_ = new_state;
     if (!state_change_callback_.is_null())
       state_change_callback_.Run(new_state);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting