[cast_channel] Make cast_channel related files not depend on "cast_channel.h"

components/cast_channel/cast_channel_enum_unittest.cc

Index: components/cast_channel/cast_channel_enum_unittest.cc
diff --git a/components/cast_channel/cast_channel_enum_unittest.cc b/components/cast_channel/cast_channel_enum_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2bfe22bc90bcba7af5ecdbd2177cb935753cade5
--- /dev/null
+++ b/components/cast_channel/cast_channel_enum_unittest.cc
@@ -0,0 +1,51 @@
+// Copyright 2017 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 "components/cast_channel/cast_channel_enum.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cast_channel {
+
+TEST(CastChannelTypeTest, TestReadyStateToString) {

[mark a. foltz, 2017/05/26 16:55:51]

Thanks for writing the unit test.  But I don't think it's worth the compilation
or maintenance time to test a function only used for debug logging.  Derek do
you feel strongly this is necessary?

[imcheng, 2017/05/26 17:43:36]

No I don't feel strongly. Thinking about it a bit more, using switch statements
should help us catch problems during compile time so unit tests are not
necessary.

[zhaobin, 2017/05/27 03:08:38]

Done.

+  EXPECT_EQ("ReadyState::NONE", ReadyStateToString(ReadyState::NONE));
+  EXPECT_EQ("ReadyState::CONNECTING",
+            ReadyStateToString(ReadyState::CONNECTING));
+  EXPECT_EQ("ReadyState::OPEN", ReadyStateToString(ReadyState::OPEN));
+  EXPECT_EQ("ReadyState::CLOSING", ReadyStateToString(ReadyState::CLOSING));
+  EXPECT_EQ("ReadyState::CLOSED", ReadyStateToString(ReadyState::CLOSED));
+}
+
+TEST(CastChannelTypeTest, TestChannelErrorToString) {
+  EXPECT_EQ("ChannelError::NONE", ChannelErrorToString(ChannelError::NONE));
+  EXPECT_EQ("ChannelError::CHANNEL_NOT_OPEN",
+            ChannelErrorToString(ChannelError::CHANNEL_NOT_OPEN));
+  EXPECT_EQ("ChannelError::AUTHENTICATION_ERROR",
+            ChannelErrorToString(ChannelError::AUTHENTICATION_ERROR));
+  EXPECT_EQ("ChannelError::CONNECT_ERROR",
+            ChannelErrorToString(ChannelError::CONNECT_ERROR));
+  EXPECT_EQ("ChannelError::SOCKET_ERROR",
+            ChannelErrorToString(ChannelError::SOCKET_ERROR));
+  EXPECT_EQ("ChannelError::TRANSPORT_ERROR",
+            ChannelErrorToString(ChannelError::TRANSPORT_ERROR));
+  EXPECT_EQ("ChannelError::INVALID_MESSAGE",
+            ChannelErrorToString(ChannelError::INVALID_MESSAGE));
+  EXPECT_EQ("ChannelError::INVALID_CHANNEL_ID",
+            ChannelErrorToString(ChannelError::INVALID_CHANNEL_ID));
+  EXPECT_EQ("ChannelError::CONNECT_TIMEOUT",
+            ChannelErrorToString(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_EQ("ChannelError::PING_TIMEOUT",
+            ChannelErrorToString(ChannelError::PING_TIMEOUT));
+  EXPECT_EQ("ChannelError::UNKNOWN",
+            ChannelErrorToString(ChannelError::UNKNOWN));
+}
+
+TEST(CastChannelTypeTest, TestChannelAuthTypeToString) {
+  EXPECT_EQ("ChannelAuthType::NONE",
+            ChannelAuthTypeToString(ChannelAuthType::NONE));
+  EXPECT_EQ("ChannelAuthType::SSL_VERIFIED",
+            ChannelAuthTypeToString(ChannelAuthType::SSL_VERIFIED));
+}
+
+}  // namespace cast_certificate