Added ConnectionTimeObserver to calculate the times to authenticate and connect.

remoting/test/test_chromoting_client.cc

 // 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/test_chromoting_client.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 42 matching lines @@
   }
 }
 
 void FetchSecret(
     const std::string& client_secret,
     bool pairing_expected,
     const remoting::protocol::SecretFetchedCallback& secret_fetched_callback) {
   secret_fetched_callback.Run(client_secret);
 }
 
-const char* ConnectionStateToFriendlyString(
-    remoting::protocol::ConnectionToHost::State state) {
-  switch (state) {
-    case remoting::protocol::ConnectionToHost::INITIALIZING:
-      return "INITIALIZING";
-
-    case remoting::protocol::ConnectionToHost::CONNECTING:
-      return "CONNECTING";
-
-    case remoting::protocol::ConnectionToHost::AUTHENTICATED:
-      return "AUTHENTICATED";
-
-    case remoting::protocol::ConnectionToHost::CONNECTED:
-      return "CONNECTED";
-
-    case remoting::protocol::ConnectionToHost::CLOSED:
-      return "CLOSED";
-
-    case remoting::protocol::ConnectionToHost::FAILED:
-      return "FAILED";
-
-    default:
-      LOG(ERROR) << "Unknown connection state: '" << state << "'";
-      return "UNKNOWN";
-  }
-}
-
-const char* ProtocolErrorToFriendlyString(
-    remoting::protocol::ErrorCode error_code) {
-  switch (error_code) {
-    case remoting::protocol::OK:
-      return "NONE";
-
-    case remoting::protocol::PEER_IS_OFFLINE:
-      return "PEER_IS_OFFLINE";
-
-    case remoting::protocol::SESSION_REJECTED:
-      return "SESSION_REJECTED";
-
-    case remoting::protocol::AUTHENTICATION_FAILED:
-      return "AUTHENTICATION_FAILED";
-
-    case remoting::protocol::INCOMPATIBLE_PROTOCOL:
-      return "INCOMPATIBLE_PROTOCOL";
-
-    case remoting::protocol::HOST_OVERLOAD:
-      return "HOST_OVERLOAD";
-
-    case remoting::protocol::CHANNEL_CONNECTION_ERROR:
-      return "CHANNEL_CONNECTION_ERROR";
-
-    case remoting::protocol::SIGNALING_ERROR:
-      return "SIGNALING_ERROR";
-
-    case remoting::protocol::SIGNALING_TIMEOUT:
-      return "SIGNALING_TIMEOUT";
-
-    case remoting::protocol::UNKNOWN_ERROR:
-      return "UNKNOWN_ERROR";
-
-    default:
-      LOG(ERROR) << "Unrecognized error code: '" << error_code << "'";
-      return "UNKNOWN_ERROR";
-  }
-}
-
 }  // namespace
 
 namespace remoting {
 namespace test {
 
 TestChromotingClient::TestChromotingClient()
     : connection_to_host_state_(protocol::ConnectionToHost::INITIALIZING),
       connection_error_code_(protocol::OK) {}
 
 TestChromotingClient::TestChromotingClient(
@@ skipping 118 matching lines @@
 
 void TestChromotingClient::SetConnectionToHostForTests(
     scoped_ptr<protocol::ConnectionToHost> connection_to_host) {
   test_connection_to_host_ = connection_to_host.Pass();
 }
 
 void TestChromotingClient::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error_code) {
   VLOG(1) << "TestChromotingClient::OnConnectionState("
-          << "state: " << ConnectionStateToFriendlyString(state) << ", "
-          << "error_code: " << ProtocolErrorToFriendlyString(error_code)
+          << "state: " << protocol::ConnectionToHost::StateToString(state)
+          << ", error_code: " << protocol::ErrorCodeToString(error_code)
           << ") Called";
 
   connection_error_code_ = error_code;
   connection_to_host_state_ = state;
 
   FOR_EACH_OBSERVER(RemoteConnectionObserver, connection_observers_,
                     ConnectionStateChanged(state, error_code));
 }
 
 void TestChromotingClient::OnConnectionReady(bool ready) {
@@ skipping 60 matching lines @@
   VLOG(1) << "TestChromotingClient::InjectClipboardEvent() Called";
 }
 
 void TestChromotingClient::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   VLOG(1) << "TestChromotingClient::SetCursorShape() Called";
 }
 
 }  // namespace test
 }  // namespace remoting