OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/signaling/fake_signal_strategy.h" | 5 #include "remoting/signaling/fake_signal_strategy.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 | 21 |
22 // static | 22 // static |
23 void FakeSignalStrategy::Connect(FakeSignalStrategy* peer1, | 23 void FakeSignalStrategy::Connect(FakeSignalStrategy* peer1, |
24 FakeSignalStrategy* peer2) { | 24 FakeSignalStrategy* peer2) { |
25 DCHECK(peer1->main_thread_->BelongsToCurrentThread()); | 25 DCHECK(peer1->main_thread_->BelongsToCurrentThread()); |
26 DCHECK(peer2->main_thread_->BelongsToCurrentThread()); | 26 DCHECK(peer2->main_thread_->BelongsToCurrentThread()); |
27 peer1->ConnectTo(peer2); | 27 peer1->ConnectTo(peer2); |
28 peer2->ConnectTo(peer1); | 28 peer2->ConnectTo(peer1); |
29 } | 29 } |
30 | 30 |
31 FakeSignalStrategy::FakeSignalStrategy(const std::string& jid) | 31 FakeSignalStrategy::FakeSignalStrategy(const SignalingAddress& address) |
32 : main_thread_(base::ThreadTaskRunnerHandle::Get()), | 32 : main_thread_(base::ThreadTaskRunnerHandle::Get()), |
33 jid_(jid), | 33 address_(address), |
34 last_id_(0), | 34 last_id_(0), |
35 weak_factory_(this) { | 35 weak_factory_(this) { |
36 DetachFromThread(); | 36 DetachFromThread(); |
37 } | 37 } |
38 | 38 |
39 FakeSignalStrategy::~FakeSignalStrategy() { | 39 FakeSignalStrategy::~FakeSignalStrategy() { |
40 while (!received_messages_.empty()) { | 40 while (!received_messages_.empty()) { |
41 delete received_messages_.front(); | 41 delete received_messages_.front(); |
42 received_messages_.pop_front(); | 42 received_messages_.pop_front(); |
43 } | 43 } |
44 } | 44 } |
45 | 45 |
46 void FakeSignalStrategy::ConnectTo(FakeSignalStrategy* peer) { | 46 void FakeSignalStrategy::ConnectTo(FakeSignalStrategy* peer) { |
47 PeerCallback peer_callback = | 47 PeerCallback peer_callback = |
48 base::Bind(&FakeSignalStrategy::DeliverMessageOnThread, | 48 base::Bind(&FakeSignalStrategy::DeliverMessageOnThread, |
49 main_thread_, | 49 main_thread_, |
50 weak_factory_.GetWeakPtr()); | 50 weak_factory_.GetWeakPtr()); |
51 if (peer->main_thread_->BelongsToCurrentThread()) { | 51 if (peer->main_thread_->BelongsToCurrentThread()) { |
52 peer->SetPeerCallback(peer_callback); | 52 peer->SetPeerCallback(peer_callback); |
53 } else { | 53 } else { |
54 peer->main_thread_->PostTask( | 54 peer->main_thread_->PostTask( |
55 FROM_HERE, | 55 FROM_HERE, |
56 base::Bind(&FakeSignalStrategy::SetPeerCallback, | 56 base::Bind(&FakeSignalStrategy::SetPeerCallback, |
57 base::Unretained(peer), | 57 base::Unretained(peer), |
58 peer_callback)); | 58 peer_callback)); |
59 } | 59 } |
60 } | 60 } |
61 | 61 |
62 void FakeSignalStrategy::SetLocalJid(const std::string& jid) { | 62 void FakeSignalStrategy::SetLocalAddress(const SignalingAddress& address) { |
63 DCHECK(CalledOnValidThread()); | 63 DCHECK(CalledOnValidThread()); |
64 jid_ = jid; | 64 address_ = address; |
65 } | 65 } |
66 | 66 |
67 void FakeSignalStrategy::SimulateMessageReordering() { | 67 void FakeSignalStrategy::SimulateMessageReordering() { |
68 DCHECK(CalledOnValidThread()); | 68 DCHECK(CalledOnValidThread()); |
69 simulate_reorder_ = true; | 69 simulate_reorder_ = true; |
70 } | 70 } |
71 | 71 |
72 void FakeSignalStrategy::Connect() { | 72 void FakeSignalStrategy::Connect() { |
73 DCHECK(CalledOnValidThread()); | 73 DCHECK(CalledOnValidThread()); |
74 for (auto& observer : listeners_) | 74 for (auto& observer : listeners_) |
75 observer.OnSignalStrategyStateChange(CONNECTED); | 75 observer.OnSignalStrategyStateChange(CONNECTED); |
76 } | 76 } |
77 | 77 |
78 void FakeSignalStrategy::Disconnect() { | 78 void FakeSignalStrategy::Disconnect() { |
79 DCHECK(CalledOnValidThread()); | 79 DCHECK(CalledOnValidThread()); |
80 for (auto& observer : listeners_) | 80 for (auto& observer : listeners_) |
81 observer.OnSignalStrategyStateChange(DISCONNECTED); | 81 observer.OnSignalStrategyStateChange(DISCONNECTED); |
82 } | 82 } |
83 | 83 |
84 SignalStrategy::State FakeSignalStrategy::GetState() const { | 84 SignalStrategy::State FakeSignalStrategy::GetState() const { |
85 return CONNECTED; | 85 return CONNECTED; |
86 } | 86 } |
87 | 87 |
88 SignalStrategy::Error FakeSignalStrategy::GetError() const { | 88 SignalStrategy::Error FakeSignalStrategy::GetError() const { |
89 return OK; | 89 return OK; |
90 } | 90 } |
91 | 91 |
92 std::string FakeSignalStrategy::GetLocalJid() const { | 92 const SignalingAddress& FakeSignalStrategy::GetLocalAddress() const { |
93 DCHECK(CalledOnValidThread()); | 93 DCHECK(CalledOnValidThread()); |
94 return jid_; | 94 return address_; |
95 } | 95 } |
96 | 96 |
97 void FakeSignalStrategy::AddListener(Listener* listener) { | 97 void FakeSignalStrategy::AddListener(Listener* listener) { |
98 DCHECK(CalledOnValidThread()); | 98 DCHECK(CalledOnValidThread()); |
99 listeners_.AddObserver(listener); | 99 listeners_.AddObserver(listener); |
100 } | 100 } |
101 | 101 |
102 void FakeSignalStrategy::RemoveListener(Listener* listener) { | 102 void FakeSignalStrategy::RemoveListener(Listener* listener) { |
103 DCHECK(CalledOnValidThread()); | 103 DCHECK(CalledOnValidThread()); |
104 listeners_.RemoveObserver(listener); | 104 listeners_.RemoveObserver(listener); |
105 } | 105 } |
106 | 106 |
107 bool FakeSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) { | 107 bool FakeSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) { |
108 DCHECK(CalledOnValidThread()); | 108 DCHECK(CalledOnValidThread()); |
109 | 109 |
110 stanza->SetAttr(buzz::QN_FROM, jid_); | 110 address_.SetInMessage(stanza.get(), SignalingAddress::FROM); |
111 | 111 |
112 if (peer_callback_.is_null()) | 112 if (peer_callback_.is_null()) |
113 return false; | 113 return false; |
114 | 114 |
115 if (send_delay_.is_zero()) { | 115 if (send_delay_.is_zero()) { |
116 peer_callback_.Run(std::move(stanza)); | 116 peer_callback_.Run(std::move(stanza)); |
117 } else { | 117 } else { |
118 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | 118 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
119 FROM_HERE, base::Bind(peer_callback_, base::Passed(&stanza)), | 119 FROM_HERE, base::Bind(peer_callback_, base::Passed(&stanza)), |
120 send_delay_); | 120 send_delay_); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
157 } | 157 } |
158 } | 158 } |
159 | 159 |
160 void FakeSignalStrategy::NotifyListeners( | 160 void FakeSignalStrategy::NotifyListeners( |
161 std::unique_ptr<buzz::XmlElement> stanza) { | 161 std::unique_ptr<buzz::XmlElement> stanza) { |
162 DCHECK(CalledOnValidThread()); | 162 DCHECK(CalledOnValidThread()); |
163 | 163 |
164 buzz::XmlElement* stanza_ptr = stanza.get(); | 164 buzz::XmlElement* stanza_ptr = stanza.get(); |
165 received_messages_.push_back(stanza.release()); | 165 received_messages_.push_back(stanza.release()); |
166 | 166 |
167 const std::string& to_field = stanza_ptr->Attr(buzz::QN_TO); | 167 std::string to_error; |
168 if (NormalizeJid(to_field) != NormalizeJid(jid_)) { | 168 SignalingAddress to = |
169 LOG(WARNING) << "Dropping stanza that is addressed to " << to_field | 169 SignalingAddress::Parse(stanza_ptr, SignalingAddress::TO, &to_error); |
170 << ". Local jid: " << jid_ | 170 if (to != address_) { |
| 171 LOG(WARNING) << "Dropping stanza that is addressed to " << to.id() |
| 172 << ". Local address: " << address_.id() |
171 << ". Message content: " << stanza_ptr->Str(); | 173 << ". Message content: " << stanza_ptr->Str(); |
172 return; | 174 return; |
173 } | 175 } |
174 | 176 |
175 for (auto& listener : listeners_) { | 177 for (auto& listener : listeners_) { |
176 if (listener.OnSignalStrategyIncomingStanza(stanza_ptr)) | 178 if (listener.OnSignalStrategyIncomingStanza(stanza_ptr)) |
177 break; | 179 break; |
178 } | 180 } |
179 } | 181 } |
180 | 182 |
181 void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) { | 183 void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) { |
182 peer_callback_ = peer_callback; | 184 peer_callback_ = peer_callback; |
183 } | 185 } |
184 | 186 |
185 } // namespace remoting | 187 } // namespace remoting |
OLD | NEW |