Added ConnectionTimeObserver to calculate the times to authenticate and connect.

remoting/protocol/connection_to_host_impl.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/protocol/connection_to_host_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/audio_reader.h"
 #include "remoting/protocol/audio_stub.h"
 #include "remoting/protocol/auth_util.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/client_video_dispatcher.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/transport.h"
 #include "remoting/protocol/video_stub.h"
 
 namespace remoting {
 namespace protocol {
 
+const char* ConnectionStateToFriendlyString(
+    remoting::protocol::ConnectionToHost::State state) {
+  switch (state) {
+    case remoting::protocol::ConnectionToHost::INITIALIZING:

[Sergey Ulanov, 2015/07/29 00:56:23]

You can use macro like this to make this code shorter:
https://code.google.com/p/chromium/codesearch#chromium/src/net/quic/quic_util...

[tonychun, 2015/07/29 16:10:13]

Done.

+      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";
+  }
+}
+
 ConnectionToHostImpl::ConnectionToHostImpl()
     : event_callback_(nullptr),
       client_stub_(nullptr),
       clipboard_stub_(nullptr),
       audio_stub_(nullptr),
       signal_strategy_(nullptr),
       state_(INITIALIZING),
       error_(OK) {
 }
 
@@ skipping 256 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting