diff --git a/remoting/client/plugin/chromoting_instance.cc b/remoting/client/plugin/chromoting_instance.cc index 9e8c291fe6f3db..cbdd17b85b2caf 100644 --- a/remoting/client/plugin/chromoting_instance.cc +++ b/remoting/client/plugin/chromoting_instance.cc @@ -98,27 +98,6 @@ const int kBandwidthHistogramBuckets = 100; const int kRandomSeedSize = 1024; #endif // defined(USE_OPENSSL) -std::string ConnectionStateToString(protocol::ConnectionToHost::State state) { - // Values returned by this function must match the - // remoting.ClientSession.State enum in JS code. - switch (state) { - case protocol::ConnectionToHost::INITIALIZING: - return "INITIALIZING"; - case protocol::ConnectionToHost::CONNECTING: - return "CONNECTING"; - case protocol::ConnectionToHost::AUTHENTICATED: - return "AUTHENTICATED"; - case protocol::ConnectionToHost::CONNECTED: - return "CONNECTED"; - case protocol::ConnectionToHost::CLOSED: - return "CLOSED"; - case protocol::ConnectionToHost::FAILED: - return "FAILED"; - } - NOTREACHED(); - return std::string(); -} - // TODO(sergeyu): Ideally we should just pass ErrorCode to the webapp // and let it handle it, but it would be hard to fix it now because // client plugin and webapp versions may not be in sync. It should be @@ -486,7 +465,7 @@ void ChromotingInstance::OnConnectionState( protocol::ConnectionToHost::State state, protocol::ErrorCode error) { scoped_ptr data(new base::DictionaryValue()); - data->SetString("state", ConnectionStateToString(state)); + data->SetString("state", protocol::ConnectionToHost::StateToString(state)); data->SetString("error", ConnectionErrorToString(error)); PostLegacyJsonMessage("onConnectionStatus", data.Pass()); } diff --git a/remoting/protocol/connection_to_host.h b/remoting/protocol/connection_to_host.h index a20bd226059864..ad9c8bafd30bd3 100644 --- a/remoting/protocol/connection_to_host.h +++ b/remoting/protocol/connection_to_host.h @@ -46,6 +46,9 @@ class ConnectionToHost { CLOSED, }; + // Returns the literal string of |state|. + static const char* StateToString(State state); + class HostEventCallback { public: virtual ~HostEventCallback() {} diff --git a/remoting/protocol/connection_to_host_impl.cc b/remoting/protocol/connection_to_host_impl.cc index f4cef0c125c855..b6dac130a47b94 100644 --- a/remoting/protocol/connection_to_host_impl.cc +++ b/remoting/protocol/connection_to_host_impl.cc @@ -48,6 +48,23 @@ ConnectionToHostImpl::~ConnectionToHostImpl() { signal_strategy_->RemoveListener(this); } +#define RETURN_STRING_LITERAL(x) \ +case x: \ +return #x; + +const char* ConnectionToHost::StateToString(State state) { + switch (state) { + RETURN_STRING_LITERAL(INITIALIZING); + RETURN_STRING_LITERAL(CONNECTING); + RETURN_STRING_LITERAL(AUTHENTICATED); + RETURN_STRING_LITERAL(CONNECTED); + RETURN_STRING_LITERAL(CLOSED); + RETURN_STRING_LITERAL(FAILED); + } + NOTREACHED(); + return nullptr; +} + void ConnectionToHostImpl::Connect( SignalStrategy* signal_strategy, scoped_ptr transport_factory, diff --git a/remoting/protocol/errors.cc b/remoting/protocol/errors.cc new file mode 100644 index 00000000000000..9c92e54d139f63 --- /dev/null +++ b/remoting/protocol/errors.cc @@ -0,0 +1,34 @@ +// 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/errors.h" + +#include "base/logging.h" + +namespace remoting { +namespace protocol { + +#define RETURN_STRING_LITERAL(x) \ +case x: \ +return #x; + +const char* ErrorCodeToString(ErrorCode error) { + switch (error) { + RETURN_STRING_LITERAL(OK); + RETURN_STRING_LITERAL(PEER_IS_OFFLINE); + RETURN_STRING_LITERAL(SESSION_REJECTED); + RETURN_STRING_LITERAL(INCOMPATIBLE_PROTOCOL); + RETURN_STRING_LITERAL(AUTHENTICATION_FAILED); + RETURN_STRING_LITERAL(CHANNEL_CONNECTION_ERROR); + RETURN_STRING_LITERAL(SIGNALING_ERROR); + RETURN_STRING_LITERAL(SIGNALING_TIMEOUT); + RETURN_STRING_LITERAL(HOST_OVERLOAD); + RETURN_STRING_LITERAL(UNKNOWN_ERROR); + } + NOTREACHED(); + return nullptr; +} + +} // namespace protocol +} // namespace remoting diff --git a/remoting/protocol/errors.h b/remoting/protocol/errors.h index 7f4daf64031c6b..4f91e23407bb3c 100644 --- a/remoting/protocol/errors.h +++ b/remoting/protocol/errors.h @@ -25,6 +25,9 @@ enum ErrorCode { UNKNOWN_ERROR, }; +// Returns the literal string of |error|. +const char* ErrorCodeToString(ErrorCode error); + } // namespace protocol } // namespace remoting diff --git a/remoting/remoting_srcs.gypi b/remoting/remoting_srcs.gypi index 8919ab08e5947a..59f56c816c56ac 100644 --- a/remoting/remoting_srcs.gypi +++ b/remoting/remoting_srcs.gypi @@ -118,6 +118,7 @@ 'protocol/content_description.cc', 'protocol/content_description.h', 'protocol/datagram_channel_factory.h', + 'protocol/errors.cc', 'protocol/errors.h', 'protocol/host_control_dispatcher.cc', 'protocol/host_control_dispatcher.h', diff --git a/remoting/remoting_test.gypi b/remoting/remoting_test.gypi index e9b6f43517a49f..048a8a774d01a1 100644 --- a/remoting/remoting_test.gypi +++ b/remoting/remoting_test.gypi @@ -60,6 +60,8 @@ 'test/chromoting_test_driver_environment.h', 'test/connection_setup_info.cc', 'test/connection_setup_info.h', + 'test/connection_time_observer.cc', + 'test/connection_time_observer.h', 'test/fake_access_token_fetcher.cc', 'test/fake_access_token_fetcher.h', 'test/fake_app_remoting_report_issue_request.cc', @@ -330,6 +332,7 @@ 'test/access_token_fetcher_unittest.cc', 'test/app_remoting_report_issue_request_unittest.cc', 'test/chromoting_test_driver_environment_unittest.cc', + 'test/connection_time_observer_unittest.cc', 'test/host_list_fetcher_unittest.cc', 'test/remote_host_info_fetcher_unittest.cc', 'test/test_chromoting_client_unittest.cc', diff --git a/remoting/test/BUILD.gn b/remoting/test/BUILD.gn index ee48b79bedef5c..d0041b9e9ea7ce 100644 --- a/remoting/test/BUILD.gn +++ b/remoting/test/BUILD.gn @@ -16,6 +16,8 @@ source_set("test_support") { "chromoting_test_driver_environment.h", "connection_setup_info.cc", "connection_setup_info.h", + "connection_time_observer.cc", + "connection_time_observer.h", "fake_access_token_fetcher.cc", "fake_access_token_fetcher.h", "fake_app_remoting_report_issue_request.cc", @@ -134,6 +136,7 @@ source_set("unit_tests") { "access_token_fetcher_unittest.cc", "app_remoting_report_issue_request_unittest.cc", "chromoting_test_driver_environment_unittest.cc", + "connection_time_observer_unittest.cc", "host_list_fetcher_unittest.cc", "remote_host_info_fetcher_unittest.cc", "test_chromoting_client_unittest.cc", diff --git a/remoting/test/chromoting_test_driver.cc b/remoting/test/chromoting_test_driver.cc index 431dac243eb401..97ab8229713a46 100644 --- a/remoting/test/chromoting_test_driver.cc +++ b/remoting/test/chromoting_test_driver.cc @@ -183,7 +183,7 @@ int main(int argc, char* argv[]) { argc, argv, base::Bind(&NoAtExitBaseTestSuite::RunTestSuite, argc, argv)); } - // Update the logging verbosity level is user specified one. + // Update the logging verbosity level if user specified one. std::string verbosity_level( command_line->GetSwitchValueASCII(switches::kLoggingLevelSwitchName)); if (!verbosity_level.empty()) { diff --git a/remoting/test/connection_time_observer.cc b/remoting/test/connection_time_observer.cc new file mode 100644 index 00000000000000..775fcbe61cbce5 --- /dev/null +++ b/remoting/test/connection_time_observer.cc @@ -0,0 +1,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 + +#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& 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 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 diff --git a/remoting/test/connection_time_observer.h b/remoting/test/connection_time_observer.h new file mode 100644 index 00000000000000..e5d83b88e623c0 --- /dev/null +++ b/remoting/test/connection_time_observer.h @@ -0,0 +1,61 @@ +// 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. + +#ifndef REMOTING_TEST_CONNECTION_TIME_OBSERVER_H_ +#define REMOTING_TEST_CONNECTION_TIME_OBSERVER_H_ + +#include + +#include "remoting/test/remote_connection_observer.h" + +namespace base { +class TimeDelta; +class Timer; +} + +namespace remoting { +namespace test { + +// Observes and saves the times when a chromoting client changes its state. It +// allows for tests to access latency times between the different states the +// client transitioned through. +class ConnectionTimeObserver + : public RemoteConnectionObserver { + public: + ConnectionTimeObserver(); + ~ConnectionTimeObserver() override; + + // RemoteConnectionObserver interface. + void ConnectionStateChanged(protocol::ConnectionToHost::State state, + protocol::ErrorCode error_code) override; + + // Prints out connection performance stats to STDOUT. + void DisplayConnectionStats() const; + + // Returns the time delta in milliseconds between |start_state| and + // |end_state| stored in |transition_times_map_|. + base::TimeDelta GetStateTransitionTime( + protocol::ConnectionToHost::State start, + protocol::ConnectionToHost::State end) const; + + // Used to set fake state transition times for ConnectionTimeObserver tests. + void SetTransitionTimesMapForTest( + const std::map& map); + + private: + // Saves the current connection state of client to host. + protocol::ConnectionToHost::State current_connection_state_ = + protocol::ConnectionToHost::State::INITIALIZING; + + // The TimeTicks to get to a state from the previous state. + std::map + transition_times_map_; + + DISALLOW_COPY_AND_ASSIGN(ConnectionTimeObserver); +}; + +} // namespace test +} // namespace remoting + +#endif // REMOTING_TEST_CONNECTION_TIME_OBSERVER_H_ diff --git a/remoting/test/connection_time_observer_unittest.cc b/remoting/test/connection_time_observer_unittest.cc new file mode 100644 index 00000000000000..3a4929a77b556b --- /dev/null +++ b/remoting/test/connection_time_observer_unittest.cc @@ -0,0 +1,176 @@ +// 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 + +#include "base/message_loop/message_loop.h" +#include "base/run_loop.h" +#include "base/time/time.h" +#include "base/timer/timer.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace remoting { +namespace test { + +class ConnectionTimeObserverTest : public ::testing::Test { + public: + ConnectionTimeObserverTest(); + ~ConnectionTimeObserverTest() override; + + protected: + // Test interface. + void SetUp() override; + + // A map of fake times to calculate TimeDelta between two states. + std::map test_map_; + + // Observes and saves the times when the chromoting connection state changes. + scoped_ptr connection_time_observer_; + + private: + DISALLOW_COPY_AND_ASSIGN(ConnectionTimeObserverTest); +}; + +ConnectionTimeObserverTest::ConnectionTimeObserverTest() { +} + +ConnectionTimeObserverTest::~ConnectionTimeObserverTest() { +} + +void ConnectionTimeObserverTest::SetUp() { + connection_time_observer_.reset(new ConnectionTimeObserver()); + + base::TimeTicks now = base::TimeTicks::Now(); + test_map_.insert(std::make_pair( + protocol::ConnectionToHost::State::INITIALIZING, + now + base::TimeDelta::FromMilliseconds(10))); + test_map_.insert(std::make_pair( + protocol::ConnectionToHost::State::CONNECTING, + now + base::TimeDelta::FromMilliseconds(20))); + test_map_.insert(std::make_pair( + protocol::ConnectionToHost::State::AUTHENTICATED, + now + base::TimeDelta::FromMilliseconds(30))); + test_map_.insert(std::make_pair( + protocol::ConnectionToHost::State::CONNECTED, + now + base::TimeDelta::FromMilliseconds(40))); + test_map_.insert(std::make_pair( + protocol::ConnectionToHost::State::CLOSED, + now + base::TimeDelta::FromMilliseconds(50))); + + connection_time_observer_->SetTransitionTimesMapForTest(test_map_); +} + +TEST_F(ConnectionTimeObserverTest, ChromotingConnectionSuccess) { + EXPECT_EQ(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::CONNECTING).InMilliseconds(), 10); + EXPECT_EQ(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::CONNECTING, + protocol::ConnectionToHost::State::AUTHENTICATED).InMilliseconds(), 10); + EXPECT_EQ(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::AUTHENTICATED, + protocol::ConnectionToHost::State::CONNECTED).InMilliseconds(), 10); + EXPECT_EQ(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::CONNECTED, + protocol::ConnectionToHost::State::CLOSED).InMilliseconds(), 10); +} + +TEST_F(ConnectionTimeObserverTest, StartStateNotFound) { + EXPECT_TRUE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::FAILED, + protocol::ConnectionToHost::State::CLOSED).is_max()); +} + +TEST_F(ConnectionTimeObserverTest, EndStateNotFound) { + EXPECT_TRUE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::FAILED).is_max()); +} + +TEST_F(ConnectionTimeObserverTest, NegativeTransitionDelay) { + EXPECT_TRUE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::CLOSED, + protocol::ConnectionToHost::State::INITIALIZING).is_max()); +} + +TEST_F(ConnectionTimeObserverTest, TestOnConnectionStateChangedWithTestMap) { + // Should fail to find FAILED. + EXPECT_TRUE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::FAILED).is_max()); + + // Registers the time at which FAILED state occurred into the map. + connection_time_observer_->ConnectionStateChanged( + protocol::ConnectionToHost::State::FAILED, + protocol::ErrorCode::PEER_IS_OFFLINE); + + EXPECT_FALSE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::FAILED).is_zero()); +} + +TEST_F(ConnectionTimeObserverTest, TestOnConnectionStateChangedWithoutTestMap) { + connection_time_observer_->SetTransitionTimesMapForTest( + std::map()); + + base::MessageLoopForIO message_loop; + base::RunLoop run_loop; + + // Should fail to find INITIALIZING in an empty map. + EXPECT_TRUE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::FAILED).is_max()); + + connection_time_observer_->ConnectionStateChanged( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ErrorCode::OK); + connection_time_observer_->ConnectionStateChanged( + protocol::ConnectionToHost::State::CONNECTING, + protocol::ErrorCode::OK); + connection_time_observer_->ConnectionStateChanged( + protocol::ConnectionToHost::State::AUTHENTICATED, + protocol::ErrorCode::OK); + + // Wait for 10 milliseconds for CONNECTED state. + // Note: This test can only guarantee a positive TimeDelta between a previous + // state and the CONNECTED state. Prior states have non-deterministic times + // between each other. + base::Timer timer(true, false); + timer.Start(FROM_HERE, + base::TimeDelta::FromMilliseconds(10), + run_loop.QuitClosure()); + run_loop.Run(); + + connection_time_observer_->ConnectionStateChanged( + protocol::ConnectionToHost::State::CONNECTED, + protocol::ErrorCode::OK); + + // Verify that the time waited is positive and at least 10 milliseconds. + EXPECT_GE(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::AUTHENTICATED, + protocol::ConnectionToHost::State::CONNECTED).InMilliseconds(), 10); +} + +TEST_F(ConnectionTimeObserverTest, TestOnConnectionStateDataDoesNotChange) { + base::TimeDelta first_time_delta = + connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::CONNECTED); + + // This check makes sure that the two states are actually found. + EXPECT_FALSE(first_time_delta.is_zero()); + + // The initial data should not change and should log an error. + connection_time_observer_->ConnectionStateChanged( + protocol::ConnectionToHost::State::CONNECTED, protocol::ErrorCode::OK); + + EXPECT_EQ(connection_time_observer_->GetStateTransitionTime( + protocol::ConnectionToHost::State::INITIALIZING, + protocol::ConnectionToHost::State::CONNECTED), first_time_delta); +} + +} // namespace test +} // namespace remoting diff --git a/remoting/test/test_chromoting_client.cc b/remoting/test/test_chromoting_client.cc index a2a102fb9c2965..7f9f1a7c7e8f5d 100644 --- a/remoting/test/test_chromoting_client.cc +++ b/remoting/test/test_chromoting_client.cc @@ -60,72 +60,6 @@ void FetchSecret( 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 { @@ -264,8 +198,8 @@ 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;