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 15 matching lines...) Expand all Loading... |
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 SignalingAddress& address) | 31 FakeSignalStrategy::FakeSignalStrategy(const SignalingAddress& address) |
32 : main_thread_(base::ThreadTaskRunnerHandle::Get()), | 32 : main_thread_(base::ThreadTaskRunnerHandle::Get()), |
33 address_(address), | 33 address_(address), |
34 last_id_(0), | 34 last_id_(0), |
35 weak_factory_(this) { | 35 weak_factory_(this) { |
36 DetachFromThread(); | 36 DETACH_FROM_SEQUENCE(sequence_checker_); |
37 } | 37 } |
38 | 38 |
39 FakeSignalStrategy::~FakeSignalStrategy() { | 39 FakeSignalStrategy::~FakeSignalStrategy() { |
| 40 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
40 while (!received_messages_.empty()) { | 41 while (!received_messages_.empty()) { |
41 delete received_messages_.front(); | 42 delete received_messages_.front(); |
42 received_messages_.pop_front(); | 43 received_messages_.pop_front(); |
43 } | 44 } |
44 } | 45 } |
45 | 46 |
46 void FakeSignalStrategy::ConnectTo(FakeSignalStrategy* peer) { | 47 void FakeSignalStrategy::ConnectTo(FakeSignalStrategy* peer) { |
47 PeerCallback peer_callback = | 48 PeerCallback peer_callback = |
48 base::Bind(&FakeSignalStrategy::DeliverMessageOnThread, | 49 base::Bind(&FakeSignalStrategy::DeliverMessageOnThread, |
49 main_thread_, | 50 main_thread_, |
50 weak_factory_.GetWeakPtr()); | 51 weak_factory_.GetWeakPtr()); |
51 if (peer->main_thread_->BelongsToCurrentThread()) { | 52 if (peer->main_thread_->BelongsToCurrentThread()) { |
52 peer->SetPeerCallback(peer_callback); | 53 peer->SetPeerCallback(peer_callback); |
53 } else { | 54 } else { |
54 peer->main_thread_->PostTask( | 55 peer->main_thread_->PostTask( |
55 FROM_HERE, | 56 FROM_HERE, |
56 base::Bind(&FakeSignalStrategy::SetPeerCallback, | 57 base::Bind(&FakeSignalStrategy::SetPeerCallback, |
57 base::Unretained(peer), | 58 base::Unretained(peer), |
58 peer_callback)); | 59 peer_callback)); |
59 } | 60 } |
60 } | 61 } |
61 | 62 |
62 void FakeSignalStrategy::SetLocalAddress(const SignalingAddress& address) { | 63 void FakeSignalStrategy::SetLocalAddress(const SignalingAddress& address) { |
63 DCHECK(CalledOnValidThread()); | 64 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
64 address_ = address; | 65 address_ = address; |
65 } | 66 } |
66 | 67 |
67 void FakeSignalStrategy::SimulateMessageReordering() { | 68 void FakeSignalStrategy::SimulateMessageReordering() { |
68 DCHECK(CalledOnValidThread()); | 69 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
69 simulate_reorder_ = true; | 70 simulate_reorder_ = true; |
70 } | 71 } |
71 | 72 |
72 void FakeSignalStrategy::Connect() { | 73 void FakeSignalStrategy::Connect() { |
73 DCHECK(CalledOnValidThread()); | 74 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
74 for (auto& observer : listeners_) | 75 for (auto& observer : listeners_) |
75 observer.OnSignalStrategyStateChange(CONNECTED); | 76 observer.OnSignalStrategyStateChange(CONNECTED); |
76 } | 77 } |
77 | 78 |
78 void FakeSignalStrategy::Disconnect() { | 79 void FakeSignalStrategy::Disconnect() { |
79 DCHECK(CalledOnValidThread()); | 80 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
80 for (auto& observer : listeners_) | 81 for (auto& observer : listeners_) |
81 observer.OnSignalStrategyStateChange(DISCONNECTED); | 82 observer.OnSignalStrategyStateChange(DISCONNECTED); |
82 } | 83 } |
83 | 84 |
84 SignalStrategy::State FakeSignalStrategy::GetState() const { | 85 SignalStrategy::State FakeSignalStrategy::GetState() const { |
85 return CONNECTED; | 86 return CONNECTED; |
86 } | 87 } |
87 | 88 |
88 SignalStrategy::Error FakeSignalStrategy::GetError() const { | 89 SignalStrategy::Error FakeSignalStrategy::GetError() const { |
89 return OK; | 90 return OK; |
90 } | 91 } |
91 | 92 |
92 const SignalingAddress& FakeSignalStrategy::GetLocalAddress() const { | 93 const SignalingAddress& FakeSignalStrategy::GetLocalAddress() const { |
93 DCHECK(CalledOnValidThread()); | 94 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
94 return address_; | 95 return address_; |
95 } | 96 } |
96 | 97 |
97 void FakeSignalStrategy::AddListener(Listener* listener) { | 98 void FakeSignalStrategy::AddListener(Listener* listener) { |
98 DCHECK(CalledOnValidThread()); | 99 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
99 listeners_.AddObserver(listener); | 100 listeners_.AddObserver(listener); |
100 } | 101 } |
101 | 102 |
102 void FakeSignalStrategy::RemoveListener(Listener* listener) { | 103 void FakeSignalStrategy::RemoveListener(Listener* listener) { |
103 DCHECK(CalledOnValidThread()); | 104 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
104 listeners_.RemoveObserver(listener); | 105 listeners_.RemoveObserver(listener); |
105 } | 106 } |
106 | 107 |
107 bool FakeSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) { | 108 bool FakeSignalStrategy::SendStanza(std::unique_ptr<buzz::XmlElement> stanza) { |
108 DCHECK(CalledOnValidThread()); | 109 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
109 | 110 |
110 address_.SetInMessage(stanza.get(), SignalingAddress::FROM); | 111 address_.SetInMessage(stanza.get(), SignalingAddress::FROM); |
111 | 112 |
112 if (peer_callback_.is_null()) | 113 if (peer_callback_.is_null()) |
113 return false; | 114 return false; |
114 | 115 |
115 if (send_delay_.is_zero()) { | 116 if (send_delay_.is_zero()) { |
116 peer_callback_.Run(std::move(stanza)); | 117 peer_callback_.Run(std::move(stanza)); |
117 } else { | 118 } else { |
118 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | 119 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
(...skipping 13 matching lines...) Expand all Loading... |
132 scoped_refptr<base::SingleThreadTaskRunner> thread, | 133 scoped_refptr<base::SingleThreadTaskRunner> thread, |
133 base::WeakPtr<FakeSignalStrategy> target, | 134 base::WeakPtr<FakeSignalStrategy> target, |
134 std::unique_ptr<buzz::XmlElement> stanza) { | 135 std::unique_ptr<buzz::XmlElement> stanza) { |
135 thread->PostTask(FROM_HERE, | 136 thread->PostTask(FROM_HERE, |
136 base::Bind(&FakeSignalStrategy::OnIncomingMessage, | 137 base::Bind(&FakeSignalStrategy::OnIncomingMessage, |
137 target, base::Passed(&stanza))); | 138 target, base::Passed(&stanza))); |
138 } | 139 } |
139 | 140 |
140 void FakeSignalStrategy::OnIncomingMessage( | 141 void FakeSignalStrategy::OnIncomingMessage( |
141 std::unique_ptr<buzz::XmlElement> stanza) { | 142 std::unique_ptr<buzz::XmlElement> stanza) { |
142 DCHECK(CalledOnValidThread()); | 143 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
143 | 144 |
144 if (!simulate_reorder_) { | 145 if (!simulate_reorder_) { |
145 NotifyListeners(std::move(stanza)); | 146 NotifyListeners(std::move(stanza)); |
146 return; | 147 return; |
147 } | 148 } |
148 | 149 |
149 // Simulate IQ messages re-ordering by swapping the delivery order of | 150 // Simulate IQ messages re-ordering by swapping the delivery order of |
150 // next pair of messages. | 151 // next pair of messages. |
151 if (pending_stanza_) { | 152 if (pending_stanza_) { |
152 NotifyListeners(std::move(stanza)); | 153 NotifyListeners(std::move(stanza)); |
153 NotifyListeners(std::move(pending_stanza_)); | 154 NotifyListeners(std::move(pending_stanza_)); |
154 pending_stanza_.reset(); | 155 pending_stanza_.reset(); |
155 } else { | 156 } else { |
156 pending_stanza_ = std::move(stanza); | 157 pending_stanza_ = std::move(stanza); |
157 } | 158 } |
158 } | 159 } |
159 | 160 |
160 void FakeSignalStrategy::NotifyListeners( | 161 void FakeSignalStrategy::NotifyListeners( |
161 std::unique_ptr<buzz::XmlElement> stanza) { | 162 std::unique_ptr<buzz::XmlElement> stanza) { |
162 DCHECK(CalledOnValidThread()); | 163 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); |
163 | 164 |
164 buzz::XmlElement* stanza_ptr = stanza.get(); | 165 buzz::XmlElement* stanza_ptr = stanza.get(); |
165 received_messages_.push_back(stanza.release()); | 166 received_messages_.push_back(stanza.release()); |
166 | 167 |
167 std::string to_error; | 168 std::string to_error; |
168 SignalingAddress to = | 169 SignalingAddress to = |
169 SignalingAddress::Parse(stanza_ptr, SignalingAddress::TO, &to_error); | 170 SignalingAddress::Parse(stanza_ptr, SignalingAddress::TO, &to_error); |
170 if (to != address_) { | 171 if (to != address_) { |
171 LOG(WARNING) << "Dropping stanza that is addressed to " << to.id() | 172 LOG(WARNING) << "Dropping stanza that is addressed to " << to.id() |
172 << ". Local address: " << address_.id() | 173 << ". Local address: " << address_.id() |
173 << ". Message content: " << stanza_ptr->Str(); | 174 << ". Message content: " << stanza_ptr->Str(); |
174 return; | 175 return; |
175 } | 176 } |
176 | 177 |
177 for (auto& listener : listeners_) { | 178 for (auto& listener : listeners_) { |
178 if (listener.OnSignalStrategyIncomingStanza(stanza_ptr)) | 179 if (listener.OnSignalStrategyIncomingStanza(stanza_ptr)) |
179 break; | 180 break; |
180 } | 181 } |
181 } | 182 } |
182 | 183 |
183 void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) { | 184 void FakeSignalStrategy::SetPeerCallback(const PeerCallback& peer_callback) { |
184 peer_callback_ = peer_callback; | 185 peer_callback_ = peer_callback; |
185 } | 186 } |
186 | 187 |
187 } // namespace remoting | 188 } // namespace remoting |
OLD | NEW |