Refactor IqRequest.

remoting/protocol/pepper_session_manager.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_manager.h"
 
 #include "base/bind.h"
+#include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/jingle_glue/jingle_info_request.h"
 #include "remoting/jingle_glue/signal_strategy.h"
 #include "remoting/protocol/jingle_messages.h"
 #include "remoting/protocol/pepper_session.h"
 #include "third_party/libjingle/source/talk/base/socketaddress.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::QName;
 
 namespace remoting {
@@ skipping 13 matching lines @@
 void PepperSessionManager::Init(
     const std::string& local_jid,
     SignalStrategy* signal_strategy,
     SessionManager::Listener* listener,
     crypto::RSAPrivateKey* private_key,
     const std::string& certificate,
     bool allow_nat_traversal) {
   listener_ = listener;
   local_jid_ = local_jid;
   signal_strategy_ = signal_strategy;
+  iq_sender_.reset(new IqSender(signal_strategy_));
   private_key_.reset(private_key);
   certificate_ = certificate;
   allow_nat_traversal_ = allow_nat_traversal;
 
-  signal_strategy_->SetListener(this);
+  signal_strategy_->AddListener(this);
 
   // If NAT traversal is enabled then we need to request STUN/Relay info.
   if (allow_nat_traversal) {
-    jingle_info_request_.reset(
-        new JingleInfoRequest(signal_strategy_->CreateIqRequest()));
-    jingle_info_request_->Send(base::Bind(
-        &PepperSessionManager::OnJingleInfo, base::Unretained(this)));
+    jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
+    jingle_info_request_->Send(base::Bind(&PepperSessionManager::OnJingleInfo,
+                                          base::Unretained(this)));
   } else {
     listener_->OnSessionManagerInitialized();
   }
 }
 
 void PepperSessionManager::OnJingleInfo(
     const std::string& relay_token,
     const std::vector<std::string>& relay_hosts,
     const std::vector<talk_base::SocketAddress>& stun_hosts) {
   DCHECK(CalledOnValidThread());
@@ skipping 25 matching lines @@
 
 void PepperSessionManager::Close() {
   DCHECK(CalledOnValidThread());
 
   // Close() can be called only after all sessions are destroyed.
   DCHECK(sessions_.empty());
 
   listener_ = NULL;
   jingle_info_request_.reset();
 
-  signal_strategy_->SetListener(NULL);
+  signal_strategy_->RemoveListener(this);
 }
 
 bool PepperSessionManager::OnIncomingStanza(const buzz::XmlElement* stanza) {
   if (!JingleMessage::IsJingleMessage(stanza))
     return false;
 
   JingleMessage message;
   std::string error;
   if (!message.ParseXml(stanza, &error)) {
     SendReply(stanza, JingleMessageReply(JingleMessageReply::BAD_REQUEST));
@@ skipping 12 matching lines @@
     SendReply(stanza, JingleMessageReply(JingleMessageReply::INVALID_SID));
     return true;
   }
 
   JingleMessageReply reply;
   it->second->OnIncomingMessage(message, &reply);
   SendReply(stanza, reply);
   return true;
 }
 
-IqRequest* PepperSessionManager::CreateIqRequest() {
-  return signal_strategy_->CreateIqRequest();
-}
-
 void PepperSessionManager::SendReply(const buzz::XmlElement* original_stanza,
                                      const JingleMessageReply& reply) {
   buzz::XmlElement* stanza = reply.ToXml(original_stanza);
   signal_strategy_->SendStanza(stanza);
 }
 
 void PepperSessionManager::SessionDestroyed(PepperSession* session) {
   sessions_.erase(session->session_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting