Added ConnectionTimeObserver to calculate the times to authenticate and connect.

remoting/test/chromoting_connection_observer.cc

Index: remoting/test/chromoting_connection_observer.cc
diff --git a/remoting/test/chromoting_connection_observer.cc b/remoting/test/chromoting_connection_observer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..032070de7f3f07c8fc6c2f1eb00c4b2ac8b1b14f
--- /dev/null
+++ b/remoting/test/chromoting_connection_observer.cc
@@ -0,0 +1,65 @@
+// 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/chromoting_connection_observer.h"
+
+#include "base/time/time.h"
+
+namespace remoting {
+namespace test {
+
+ChromotingConnectionObserver::ChromotingConnectionObserver()
+    : current_state_(protocol::ConnectionToHost::State::INITIALIZING) {
+  state_map_ = {
+      {protocol::ConnectionToHost::State::INITIALIZING, "INITIALIZING"},
+      {protocol::ConnectionToHost::State::CONNECTING, "CONNECTING"},
+      {protocol::ConnectionToHost::State::AUTHENTICATED, "AUTHENTICATED"},
+      {protocol::ConnectionToHost::State::CONNECTED, "CONNECTED"},
+      {protocol::ConnectionToHost::State::FAILED, "FAILED"},
+      {protocol::ConnectionToHost::State::CLOSED, "CLOSED"}};

[joedow, 2015/07/20 16:30:57]

I think this would be cleaner as a file-scoped function in an anonymous
namespace.  You can basically just make a switch and return a value.  It is
easier to log errors there (using a default case) vs. having to check if a value
exists before accessing the map.

[tonychun, 2015/07/20 17:49:59]

I moved it all into a switch.

+  delta_ = base::TimeTicks::Now();

[joedow, 2015/07/20 16:30:58]

Why are you initializing this in the C'Tor?  This seems odd as the class could
be created a long time (in computer time) from when the connection is started.

[tonychun, 2015/07/20 17:49:59]

If I don't do this, I get this error:

INITIALIZING to CONNECTING Delta Time: 592674719 ms

If I initialize it, it becomes:

INITIALIZING to CONNECTING Delta Time: 1 ms

I've seen the range from INITIALIZING to CONNECTING change from 1 ms to 3 ms on
my local machine. ConnectionStateChanged is called very soon after the
initialization of the class. In addition, we aren't looking for that metric, so
the time between these two states are not important for Sergey or Anand.

+}
+
+ChromotingConnectionObserver::~ChromotingConnectionObserver() {
+}
+
+void ChromotingConnectionObserver::ConnectionStateChanged(
+    protocol::ConnectionToHost::State state,
+    protocol::ErrorCode error_code) {

[joedow, 2015/07/20 16:30:57]

Do you care about errors?

[tonychun, 2015/07/20 17:49:59]

A log error is output already through the TestChromotingClient.

Example:
"
TestChromotingClient::OnConnectionState(state: CONNECTING, error_code: NONE)
Called
INITIALIZING to CONNECTING Delta Time: 1 ms
TestChromotingClient::OnConnectionState(state: FAILED, error_code:
AUTHENTICATION_FAILED) Called
CONNECTING to FAILED Delta Time: 505 ms
"

On any rate, I don't need to know about the error code. I only need transition
times.

+  base::TimeTicks new_delta = base::TimeTicks::Now();
+
+  VLOG(1) << state_map_.at(current_state_) << " to " << state_map_.at(state)
+          << " Delta Time: " << (new_delta - delta_).InMilliseconds() << " ms";
+
+  current_state_ = state;
+  delta_ = base::TimeTicks::Now();
+}
+
+void ChromotingConnectionObserver::ConnectionReady(bool ready) {
+  VLOG(1) << "ChromotingConnectionObserver::ConnectionReady Called";
+}

[joedow, 2015/07/20 16:30:57]

You don't need to implement any of these functions if you aren't calc'ing any
data in them.  IIRC the test_chromoting_client already VLOGs the messages they
come in so this is just adding spam to the log output.

[tonychun, 2015/07/20 17:49:59]

Done.

+
+void ChromotingConnectionObserver::RouteChanged(
+    const std::string& channel_name,
+    const protocol::TransportRoute& route) {
+  VLOG(1) << "ChromotingConnectionObserver::RouteChanged Called";
+}
+
+void ChromotingConnectionObserver::CapabilitiesSet(
+    const std::string& capabilities) {
+  VLOG(1) << "ChromotingConnectionObserver::CapabilitiesSet Called";
+}
+
+void ChromotingConnectionObserver::PairingResponseSet(
+    const protocol::PairingResponse& pairing_response) {
+  VLOG(1) << "ChromotingConnectionObserver::PairingResponseSet Called";
+}
+
+void ChromotingConnectionObserver::HostMessageReceived(
+    const protocol::ExtensionMessage& message) {
+  VLOG(1) << "ChromotingConnectionObserver::HostMessageReceived Called";
+}
+
+}  // namespace test
+}  // namespace remoting