OLD | NEW |
(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 |
OLD | NEW |