remoting/signaling/fake_signal_strategy.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/signaling/fake_signal_strategy.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/single_thread_task_runner.h"
  11 #include "base/stl_util.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
  15 #include "third_party/webrtc/libjingle/xmpp/constants.h"
  16
  17 namespace remoting {
  18
  19 // static
  20 void FakeSignalStrategy::Connect(FakeSignalStrategy* peer1,
  21                                  FakeSignalStrategy* peer2) {
  22   DCHECK(peer1->main_thread_->BelongsToCurrentThread());
  23   DCHECK(peer2->main_thread_->BelongsToCurrentThread());
  24   peer1->ConnectTo(peer2);
  25   peer2->ConnectTo(peer1);
  26 }
  27
  28 FakeSignalStrategy::FakeSignalStrategy(const std::string& jid)
  29     : main_thread_(base::ThreadTaskRunnerHandle::Get()),
  30       jid_(jid),
  31       last_id_(0),
  32       weak_factory_(this) {
  33
  34 }
  35
  36 FakeSignalStrategy::~FakeSignalStrategy() {
  37   while (!received_messages_.empty()) {
  38     delete received_messages_.front();
  39     received_messages_.pop_front();
  40   }
  41 }
  42
  43 void FakeSignalStrategy::ConnectTo(FakeSignalStrategy* peer) {
  44   PeerCallback peer_callback =
  45       base::Bind(&FakeSignalStrategy::DeliverMessageOnThread,
  46                  main_thread_,
  47                  weak_factory_.GetWeakPtr());
  48   if (peer->main_thread_->BelongsToCurrentThread()) {
  49     peer->SetPeerCallback(peer_callback);
  50   } else {
  51     peer->main_thread_->PostTask(
  52         FROM_HERE,
  53         base::Bind(&FakeSignalStrategy::SetPeerCallback,
  54                    base::Unretained(peer),
  55                    peer_callback));
  56   }
  57 }
  58
  59 void FakeSignalStrategy::Connect() {
  60   DCHECK(CalledOnValidThread());
  61   FOR_EACH_OBSERVER(Listener, listeners_,
  62                     OnSignalStrategyStateChange(CONNECTED));
  63 }
  64
  65 void FakeSignalStrategy::Disconnect() {
  66   DCHECK(CalledOnValidThread());
  67   FOR_EACH_OBSERVER(Listener, listeners_,
  68                     OnSignalStrategyStateChange(DISCONNECTED));
  69 }
  70
  71 SignalStrategy::State FakeSignalStrategy::GetState() const {
  72   return CONNECTED;
  73 }
  74
  75 SignalStrategy::Error FakeSignalStrategy::GetError() const {
  76   return OK;
  77 }
  78
  79 std::string FakeSignalStrategy::GetLocalJid() const {
  80   DCHECK(CalledOnValidThread());
  81   return jid_;
  82 }
  83
  84 void FakeSignalStrategy::AddListener(Listener* listener) {
  85   DCHECK(CalledOnValidThread());
  86   listeners_.AddObserver(listener);
  87 }
  88
  89 void FakeSignalStrategy::RemoveListener(Listener* listener) {
  90   DCHECK(CalledOnValidThread());
  91   listeners_.RemoveObserver(listener);
  92 }
  93
  94 bool FakeSignalStrategy::SendStanza(scoped_ptr<buzz::XmlElement> stanza) {
  95   DCHECK(CalledOnValidThread());
  96
  97   stanza->SetAttr(buzz::QN_FROM, jid_);
  98
  99   if (!peer_callback_.is_null()) {
 100     if (send_delay_ != base::TimeDelta()) {
 101       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 102           FROM_HERE, base::Bind(peer_callback_, base::Passed(&stanza)),
 103           send_delay_);
 104     } else {
 105       peer_callback_.Run(stanza.Pass());
 106     }
 107     return true;
 108   } else {
 109     return false;
 110   }
 111 }
 112
 113 std::string FakeSignalStrategy::GetNextId() {
 114   ++last_id_;
 115   return base::IntToString(last_id_);
 116 }
 117
 118 // static
 119 void FakeSignalStrategy::DeliverMessageOnThread(
 120     scoped_refptr<base::SingleThreadTaskRunner> thread,
 121     base::WeakPtr<FakeSignalStrategy> target,
 122     scoped_ptr<buzz::XmlElement> stanza) {
 123   thread->PostTask(FROM_HERE,
 124                    base::Bind(&FakeSignalStrategy::OnIncomingMessage,
 125                               target, base::Passed(&stanza)));
 126 }
 127
 128 void FakeSignalStrategy::OnIncomingMessage(
 129     scoped_ptr<buzz::XmlElement> stanza) {
 130   DCHECK(CalledOnValidThread());
 131
 132   buzz::XmlElement* stanza_ptr = stanza.get();
 133   received_messages_.push_back(stanza.release());
 134
 135   const std::string& to_field = stanza_ptr->Attr(buzz::QN_TO);
 136   if (to_field != jid_) {
 137     LOG(WARNING) << "Dropping stanza that is addressed to " << to_field
 138                  << ". Local jid: " << jid_
 139                  << ". Message content: " << stanza_ptr->Str();
 140     return;
 141   }
 142
 143   ObserverListBase<Listener>::Iterator it(&listeners_);
 144   Listener* listener;
 145   while ((listener = it.GetNext()) != nullptr) {
 146     if (listener->OnSignalStrategyIncomingStanza(stanza_ptr))
 147       break;
 148   }
 149 }
 150
 151 void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) {
 152   peer_callback_ = peer_callback;
 153 }
 154
 155 }  // namespace remoting