1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/test/connection_time_observer.h"
#include <utility>
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
namespace remoting {
namespace test {
ConnectionTimeObserver::ConnectionTimeObserver() {
}
ConnectionTimeObserver::~ConnectionTimeObserver() {
}
void ConnectionTimeObserver::SetTransitionTimesMapForTest(
const std::map<protocol::ConnectionToHost::State, base::TimeTicks>& map) {
transition_times_map_ = map;
}
void ConnectionTimeObserver::ConnectionStateChanged(
protocol::ConnectionToHost::State state,
protocol::ErrorCode error_code) {
if (transition_times_map_.find(state) != transition_times_map_.end()) {
std::string connection_state =
protocol::ConnectionToHost::StateToString(state);
LOG(ERROR) << connection_state << " state has already been set";
return;
}
transition_times_map_.insert(std::make_pair(state, base::TimeTicks::Now()));
current_connection_state_ = state;
}
void ConnectionTimeObserver::DisplayConnectionStats() const {
protocol::ConnectionToHost::State initializing =
protocol::ConnectionToHost::State::INITIALIZING;
protocol::ConnectionToHost::State current_state = initializing;
const char kStateChangeTitleFormatString[] = "%-35s%-15s";
LOG(INFO) << base::StringPrintf(kStateChangeTitleFormatString,
"State to State", "Delta Time");
LOG(INFO) << base::StringPrintf(kStateChangeTitleFormatString,
"--------------", "----------");
// Note: the order of |connected_states| mimics the expected order of when a
// connection is made.
std::vector<protocol::ConnectionToHost::State> connected_states;
connected_states.push_back(protocol::ConnectionToHost::State::CONNECTING);
connected_states.push_back(protocol::ConnectionToHost::State::AUTHENTICATED);
connected_states.push_back(protocol::ConnectionToHost::State::CONNECTED);
connected_states.push_back(protocol::ConnectionToHost::State::FAILED);
const char kStateChangeFormatString[] = "%-13s to %-18s%-7dms";
auto iter_end = transition_times_map_.end();
for (protocol::ConnectionToHost::State state : connected_states) {
auto iter_state = transition_times_map_.find(state);
if (iter_state != iter_end) {
int state_transition_time =
GetStateTransitionTime(current_state, state).InMilliseconds();
LOG(INFO) << base::StringPrintf(kStateChangeFormatString,
protocol::ConnectionToHost::StateToString(current_state),
protocol::ConnectionToHost::StateToString(state),
state_transition_time);
current_state = state;
}
}
int connected_time =
GetStateTransitionTime(initializing, current_state).InMilliseconds();
// |current state| will either be FAILED or CONNECTED.
LOG(INFO) << "Total Connection Duration (INITIALIZING to "
<< protocol::ConnectionToHost::StateToString(current_state) << "): "
<< connected_time << " ms";
}
base::TimeDelta ConnectionTimeObserver::GetStateTransitionTime(
protocol::ConnectionToHost::State start,
protocol::ConnectionToHost::State end) const {
auto iter_end = transition_times_map_.end();
auto iter_start_state = transition_times_map_.find(start);
std::string start_state = protocol::ConnectionToHost::StateToString(start);
if (iter_start_state == iter_end) {
LOG(ERROR) << "No time found for state: " << start_state;
return base::TimeDelta::Max();
}
auto iter_end_state = transition_times_map_.find(end);
std::string end_state = protocol::ConnectionToHost::StateToString(end);
if (iter_end_state == iter_end) {
LOG(ERROR) << "No time found for state: " << end_state;
return base::TimeDelta::Max();
}
base::TimeDelta delta = iter_end_state->second - iter_start_state->second;
if (delta.InMilliseconds() < 0) {
LOG(ERROR) << "Transition delay is negative. Check the state ordering: "
<< "[start: " << start_state << ", end: " << end_state << "]";
return base::TimeDelta::Max();
}
return delta;
}
} // namespace test
} // namespace remoting
|
