Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1185)

Side by Side Diff: remoting/test/fake_connection_event_logger.cc

Issue 1923573006: Implement a dummy host to do capturing and analysis only. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Resolve review commnets Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « remoting/test/fake_connection_event_logger.h ('k') | remoting/test/it2me_standalone_host.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2016 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/test/fake_connection_event_logger.h"
6
7 #include <string>
8
9 #include "base/atomicops.h"
10 #include "base/callback.h"
11 #include "base/macros.h"
12 #include "base/time/time.h"
13 #include "remoting/proto/audio.pb.h"
14 #include "remoting/proto/control.pb.h"
15 #include "remoting/proto/video.pb.h"
16
17 #ifndef ARCH_CPU_64_BITS
18 #include "base/synchronization/lock.h"
19 #endif
20
21 namespace remoting {
22 namespace test {
23 namespace {
24
25 template <typename T>
26 class NoBarrierAtomic {
27 public:
28 T operator++() {
29 return base::subtle::NoBarrier_AtomicIncrement(&i_, 1) - 1;
30 }
31
32 T operator++(int) {
33 return base::subtle::NoBarrier_AtomicIncrement(&i_, 1);
34 }
35
36 T operator--() {
37 return base::subtle::NoBarrier_AtomicIncrement(&i_, -1) - 1;
38 }
39
40 T operator--(int) {
41 return base::subtle::NoBarrier_AtomicIncrement(&i_, -1);
42 }
43
44 T operator+=(T other) {
45 return base::subtle::NoBarrier_AtomicIncrement(&i_, other);
46 }
47
48 T operator-=(T other) {
49 return base::subtle::NoBarrier_AtomicIncrement(&i_, -other);
50 }
51
52 T operator*() const {
53 return base::subtle::NoBarrier_Load(&i_);
54 }
55
56 private:
57 volatile T i_;
58 };
59
60 class NoBarrierAtomicInt32 : public NoBarrierAtomic<base::subtle::Atomic32> {};
61 #ifdef ARCH_CPU_64_BITS
62 class NoBarrierAtomicInt64 : public NoBarrierAtomic<base::subtle::Atomic64> {};
63 #else // ifdef ARCH_CPU_64_BITS
64
65 using base::AutoLock;
66
67 // A barriered, lock based implementation
68 class NoBarrierAtomicInt64 {
69 public:
70 int64_t operator++();
71 int64_t operator++(int);
72 int64_t operator--();
73 int64_t operator--(int);
74 int64_t operator+=(int64_t other);
75 int64_t operator-=(int64_t other);
76 int64_t operator*() const;
77
78 private:
79 volatile int64_t i_ = 0;
80 mutable base::Lock lock_; // field is used in operator*() const
81 };
82
83 int64_t NoBarrierAtomicInt64::operator++() {
84 AutoLock l(lock_);
85 return i_++;
86 }
87
88 int64_t NoBarrierAtomicInt64::operator++(int) {
89 AutoLock l(lock_);
90 return ++i_;
91 }
92
93 int64_t NoBarrierAtomicInt64::operator--() {
94 AutoLock l(lock_);
95 return i_--;
96 }
97
98 int64_t NoBarrierAtomicInt64::operator--(int) {
99 AutoLock l(lock_);
100 return --i_;
101 }
102
103 int64_t NoBarrierAtomicInt64::operator+=(int64_t other) {
104 AutoLock l(lock_);
105 return (i_ += other);
106 }
107
108 int64_t NoBarrierAtomicInt64::operator-=(int64_t other) {
109 AutoLock l(lock_);
110 return (i_ -= other);
111 }
112
113 int64_t NoBarrierAtomicInt64::operator*() const {
114 AutoLock l(lock_);
115 return i_;
116 }
117
118 #endif // ifdef ARCH_CPU_64_BITS
119
120 class MessageCounter {
121 public:
122 explicit MessageCounter(const char* name);
123
124 int message_count() const { return *count_; }
125 int64_t message_size() const { return *size_; }
126 int last_message_size() const { return last_size_; }
127 double DurationSeconds() const;
128 double MessagesPerSecond() const;
129 double SizePerSecond() const;
130 double AverageMessageSize() const;
131 void LogMessage(const ::google::protobuf::MessageLite& message);
132 void DisplayStatistics(std::ostream& os);
133
134 private:
135 std::string name_;
136 NoBarrierAtomicInt32 count_;
137 NoBarrierAtomicInt64 size_;
138 int last_size_ = 0;
139 base::Time start_time_;
140
141 // Copy or assign the start_time_ of a MessageCounter is senseless.
142 DISALLOW_COPY_AND_ASSIGN(MessageCounter);
143 };
144
145 MessageCounter::MessageCounter(const char* name)
146 : name_(name),
147 count_(),
148 size_(),
149 start_time_(base::Time::Now()) {}
150
151 double MessageCounter::DurationSeconds() const {
152 return (base::Time::Now() - start_time_).InSecondsF();
153 }
154
155 double MessageCounter::MessagesPerSecond() const {
156 return static_cast<double>(message_count()) / DurationSeconds();
157 }
158 double MessageCounter::SizePerSecond() const {
159 return static_cast<double>(message_size()) / DurationSeconds();
160 }
161
162 double MessageCounter::AverageMessageSize() const {
163 return static_cast<double>(message_size()) / message_count();
164 }
165
166 void MessageCounter::LogMessage(
167 const ::google::protobuf::MessageLite& message) {
168 count_++;
169 last_size_ = message.ByteSize();
170 size_ += message.ByteSize();
171 }
172
173 void MessageCounter::DisplayStatistics(std::ostream& os) {
174 os << name_
175 << ": "
176 << message_size()
177 << " bytes in "
178 << message_count()
179 << " packages, last package "
180 << last_message_size()
181 << " bytes, "
182 << AverageMessageSize()
183 << " bytes/package, "
184 << MessagesPerSecond()
185 << " packages/sec, "
186 << SizePerSecond()
187 << " bytes/sec"
188 << std::endl;
189 }
190
191 } // namespace
192
193 // Analyzes messages from DeliverHostMessage function.
194 class FakeConnectionEventLogger::CounterClientStub
195 : public protocol::ClientStub, public MessageCounter {
196 public:
197 CounterClientStub();
198
199 private:
200 void DeliverHostMessage(const protocol::ExtensionMessage& message) override;
201 void InjectClipboardEvent(const protocol::ClipboardEvent& event) override {}
202 void SetCapabilities(const protocol::Capabilities& capabilities) override {}
203 void SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) override {}
204 void SetPairingResponse(const protocol::PairingResponse& response) override {}
205 void SetVideoLayout(const protocol::VideoLayout& video_layout) override {}
206 };
207
208 FakeConnectionEventLogger::CounterClientStub::CounterClientStub()
209 : MessageCounter("client") {}
210
211 void FakeConnectionEventLogger::CounterClientStub::DeliverHostMessage(
212 const protocol::ExtensionMessage& message) {
213 LogMessage(message);
214 }
215
216 // Analyzes messages from DeliverClientMessage function.
217 class FakeConnectionEventLogger::CounterHostStub
218 : public protocol::HostStub, public MessageCounter {
219 public:
220 CounterHostStub();
221
222 private:
223 void ControlAudio(const protocol::AudioControl& audio_control) override {}
224 void ControlVideo(const protocol::VideoControl& video_control) override {}
225 void DeliverClientMessage(const protocol::ExtensionMessage& message) override;
226 void NotifyClientResolution(
227 const protocol::ClientResolution& resolution) override {}
228 void RequestPairing(
229 const protocol::PairingRequest& pairing_request) override {}
230 void SetCapabilities(const protocol::Capabilities& capabilities) override {}
231 };
232
233 FakeConnectionEventLogger::CounterHostStub::CounterHostStub()
234 : MessageCounter("host") {}
235
236 void FakeConnectionEventLogger::CounterHostStub::DeliverClientMessage(
237 const protocol::ExtensionMessage& message) {
238 LogMessage(message);
239 }
240
241 // Analyzes messages from ProcessAudioPacket function.
242 class FakeConnectionEventLogger::CounterAudioStub
243 : public protocol::AudioStub, public MessageCounter {
244 public:
245 CounterAudioStub();
246
247 private:
248 void ProcessAudioPacket(std::unique_ptr<AudioPacket> audio_packet,
249 const base::Closure& done) override;
250 };
251
252 FakeConnectionEventLogger::CounterAudioStub::CounterAudioStub()
253 : MessageCounter("audio") {}
254
255 void FakeConnectionEventLogger::CounterAudioStub::ProcessAudioPacket(
256 std::unique_ptr<AudioPacket> audio_packet,
257 const base::Closure& done) {
258 if (audio_packet) {
259 LogMessage(*audio_packet);
260 }
261 done.Run();
262 }
263
264 // Analyzes messages from ProcessVideoPacket function.
265 class FakeConnectionEventLogger::CounterVideoStub
266 : public protocol::VideoStub, public MessageCounter {
267 public:
268 CounterVideoStub(protocol::FakeConnectionToClient* connection);
269
270 private:
271 void ProcessVideoPacket(std::unique_ptr<VideoPacket> video_packet,
272 const base::Closure& done) override;
273
274 protocol::FakeConnectionToClient* connection_ = nullptr;
275 };
276
277 FakeConnectionEventLogger::CounterVideoStub::CounterVideoStub(
278 protocol::FakeConnectionToClient* connection)
279 : MessageCounter("video"),
280 connection_(connection) {}
281
282 void FakeConnectionEventLogger::CounterVideoStub::ProcessVideoPacket(
283 std::unique_ptr<VideoPacket> video_packet,
284 const base::Closure& done) {
285 if (video_packet && video_packet->has_capture_overhead_time_ms()) {
286 // Not a keepalive packet.
287 if (connection_ &&
288 connection_->video_feedback_stub()) {
289 std::unique_ptr<VideoAck> ack(new VideoAck());
290 ack->set_frame_id(video_packet->frame_id());
291 connection_->video_feedback_stub()->ProcessVideoAck(std::move(ack));
292 }
293 LogMessage(*video_packet);
294 }
295 done.Run();
296 }
297
298 FakeConnectionEventLogger::FakeConnectionEventLogger(
299 protocol::FakeConnectionToClient* connection)
300 : client_stub_(new CounterClientStub()),
301 host_stub_(new CounterHostStub()),
302 audio_stub_(new CounterAudioStub()),
303 video_stub_(new CounterVideoStub(connection)) {}
304
305 FakeConnectionEventLogger::~FakeConnectionEventLogger() {}
306
307 protocol::ClientStub* FakeConnectionEventLogger::client_stub() {
308 return client_stub_.get();
309 }
310
311 protocol::HostStub* FakeConnectionEventLogger::host_stub() {
312 return host_stub_.get();
313 }
314
315 protocol::AudioStub* FakeConnectionEventLogger::audio_stub() {
316 return audio_stub_.get();
317 }
318
319 protocol::VideoStub* FakeConnectionEventLogger::video_stub() {
320 return video_stub_.get();
321 }
322
323 std::ostream& operator<<(std::ostream& os,
324 const FakeConnectionEventLogger& logger) {
325 logger.audio_stub_->DisplayStatistics(os);
326 logger.video_stub_->DisplayStatistics(os);
327 logger.client_stub_->DisplayStatistics(os);
328 logger.host_stub_->DisplayStatistics(os);
329 return os;
330 }
331
332 } // namespace test
333 } // namespace remoting
OLDNEW
« no previous file with comments | « remoting/test/fake_connection_event_logger.h ('k') | remoting/test/it2me_standalone_host.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698