Revert of [cast_channel] Move cast_channel related files from //extensions to //components

extensions/browser/api/cast_channel/cast_message_util.cc

Index: extensions/browser/api/cast_channel/cast_message_util.cc
diff --git a/extensions/browser/api/cast_channel/cast_message_util.cc b/extensions/browser/api/cast_channel/cast_message_util.cc
index 2d15891134b09439c3a50b59df4dbfe091f7292d..3b646610642902fc7ba7822bda2b45e6ed72bd87 100644
--- a/extensions/browser/api/cast_channel/cast_message_util.cc
+++ b/extensions/browser/api/cast_channel/cast_message_util.cc
@@ -9,21 +9,29 @@
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
-#include "components/cast_channel/proto/cast_channel.pb.h"
+#include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/common/api/cast_channel.h"
+#include "extensions/common/api/cast_channel/cast_channel.pb.h"
+
+namespace {
+static const char kAuthNamespace[] =
+    "urn:x-cast:com.google.cast.tp.deviceauth";
+// Sender and receiver IDs to use for platform messages.
+static const char kPlatformSenderId[] = "sender-0";
+static const char kPlatformReceiverId[] = "receiver-0";
+}  // namespace
 
 namespace extensions {
 namespace api {
 namespace cast_channel {
 
 bool MessageInfoToCastMessage(const MessageInfo& message,
-                              ::cast_channel::CastMessage* message_proto) {
+                              CastMessage* message_proto) {
   DCHECK(message_proto);
   if (!message.data)
     return false;
 
-  message_proto->set_protocol_version(
-      ::cast_channel::CastMessage_ProtocolVersion_CASTV2_1_0);
+  message_proto->set_protocol_version(CastMessage_ProtocolVersion_CASTV2_1_0);
   message_proto->set_source_id(message.source_id);
   message_proto->set_destination_id(message.destination_id);
   message_proto->set_namespace_(message.namespace_);
@@ -34,15 +42,13 @@
     // JS string
     case base::Value::Type::STRING:
       if (message.data->GetAsString(&data)) {
-        message_proto->set_payload_type(
-            ::cast_channel::CastMessage_PayloadType_STRING);
+        message_proto->set_payload_type(CastMessage_PayloadType_STRING);
         message_proto->set_payload_utf8(data);
       }
       break;
     // JS ArrayBuffer
     case base::Value::Type::BINARY:
-      message_proto->set_payload_type(
-          ::cast_channel::CastMessage_PayloadType_BINARY);
+      message_proto->set_payload_type(CastMessage_PayloadType_BINARY);
       message_proto->set_payload_binary(message.data->GetBlob().data(),
                                         message.data->GetBlob().size());
       break;
@@ -54,7 +60,18 @@
   return message_proto->IsInitialized();
 }
 
-bool CastMessageToMessageInfo(const ::cast_channel::CastMessage& message_proto,
+bool IsCastMessageValid(const CastMessage& message_proto) {
+  if (message_proto.namespace_().empty() || message_proto.source_id().empty() ||
+      message_proto.destination_id().empty()) {
+    return false;
+  }
+  return (message_proto.payload_type() == CastMessage_PayloadType_STRING &&
+          message_proto.has_payload_utf8()) ||
+         (message_proto.payload_type() == CastMessage_PayloadType_BINARY &&
+          message_proto.has_payload_binary());
+}
+
+bool CastMessageToMessageInfo(const CastMessage& message_proto,
                               MessageInfo* message) {
   DCHECK(message);
   message->source_id = message_proto.source_id();
@@ -63,19 +80,19 @@
   // Determine the type of the payload and fill base::Value appropriately.
   std::unique_ptr<base::Value> value;
   switch (message_proto.payload_type()) {
-    case ::cast_channel::CastMessage_PayloadType_STRING:
-      if (message_proto.has_payload_utf8())
-        value.reset(new base::Value(message_proto.payload_utf8()));
-      break;
-    case ::cast_channel::CastMessage_PayloadType_BINARY:
-      if (message_proto.has_payload_binary())
-        value = base::Value::CreateWithCopiedBuffer(
-            message_proto.payload_binary().data(),
-            message_proto.payload_binary().size());
-      break;
-    default:
-      // Unknown payload type. value will remain unset.
-      break;
+  case CastMessage_PayloadType_STRING:
+    if (message_proto.has_payload_utf8())
+      value.reset(new base::Value(message_proto.payload_utf8()));
+    break;
+  case CastMessage_PayloadType_BINARY:
+    if (message_proto.has_payload_binary())
+      value = base::Value::CreateWithCopiedBuffer(
+          message_proto.payload_binary().data(),
+          message_proto.payload_binary().size());
+    break;
+  default:
+    // Unknown payload type. value will remain unset.
+    break;
   }
   if (value.get()) {
     DCHECK(!message->data.get());
@@ -86,6 +103,58 @@
   }
 }
 
+std::string CastMessageToString(const CastMessage& message_proto) {
+  std::string out("{");
+  out += "namespace = " + message_proto.namespace_();
+  out += ", sourceId = " + message_proto.source_id();
+  out += ", destId = " + message_proto.destination_id();
+  out += ", type = " + base::IntToString(message_proto.payload_type());
+  out += ", str = \"" + message_proto.payload_utf8() + "\"}";
+  return out;
+}
+
+std::string AuthMessageToString(const DeviceAuthMessage& message) {
+  std::string out("{");
+  if (message.has_challenge()) {
+    out += "challenge: {}, ";
+  }
+  if (message.has_response()) {
+    out += "response: {signature: (";
+    out += base::SizeTToString(message.response().signature().length());
+    out += " bytes), certificate: (";
+    out += base::SizeTToString(
+        message.response().client_auth_certificate().length());
+    out += " bytes)}";
+  }
+  if (message.has_error()) {
+    out += ", error: {";
+    out += base::IntToString(message.error().error_type());
+    out += "}";
+  }
+  out += "}";
+  return out;
+}
+
+void CreateAuthChallengeMessage(CastMessage* message_proto,
+                                const AuthContext& auth_context) {
+  CHECK(message_proto);
+  DeviceAuthMessage auth_message;
+  auth_message.mutable_challenge()->set_sender_nonce(auth_context.nonce());
+  std::string auth_message_string;
+  auth_message.SerializeToString(&auth_message_string);
+
+  message_proto->set_protocol_version(CastMessage_ProtocolVersion_CASTV2_1_0);
+  message_proto->set_source_id(kPlatformSenderId);
+  message_proto->set_destination_id(kPlatformReceiverId);
+  message_proto->set_namespace_(kAuthNamespace);
+  message_proto->set_payload_type(CastMessage_PayloadType_BINARY);
+  message_proto->set_payload_binary(auth_message_string);
+}
+
+bool IsAuthMessage(const CastMessage& message) {
+  return message.namespace_() == kAuthNamespace;
+}
+
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions