[vlc-devel] [PATCH 4/5] chromecast: add protobuf generated files

[magsoft at videolan.org]

From: Adrien Maglo <magsoft at videolan.org>

---
 modules/stream_out/chromecast/cast_channel.pb.cc | 1306 +++++++++++++++++++++
 modules/stream_out/chromecast/cast_channel.pb.h  | 1357 ++++++++++++++++++++++
 modules/stream_out/chromecast/cast_channel.proto |   79 ++
 3 files changed, 2742 insertions(+)
 create mode 100644 modules/stream_out/chromecast/cast_channel.pb.cc
 create mode 100644 modules/stream_out/chromecast/cast_channel.pb.h
 create mode 100644 modules/stream_out/chromecast/cast_channel.proto

diff --git a/modules/stream_out/chromecast/cast_channel.pb.cc b/modules/stream_out/chromecast/cast_channel.pb.cc
new file mode 100644
index 0000000..7794510
--- /dev/null
+++ b/modules/stream_out/chromecast/cast_channel.pb.cc
@@ -0,0 +1,1306 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: cast_channel.proto
+// protoc --cpp_out=. cast_channel.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "cast_channel.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+// @@protoc_insertion_point(includes)
+
+namespace castchannel {
+
+void protobuf_ShutdownFile_cast_5fchannel_2eproto() {
+  delete CastMessage::default_instance_;
+  delete AuthChallenge::default_instance_;
+  delete AuthResponse::default_instance_;
+  delete AuthError::default_instance_;
+  delete DeviceAuthMessage::default_instance_;
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+void protobuf_AddDesc_cast_5fchannel_2eproto_impl() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#else
+void protobuf_AddDesc_cast_5fchannel_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+#endif
+  CastMessage::default_instance_ = new CastMessage();
+  AuthChallenge::default_instance_ = new AuthChallenge();
+  AuthResponse::default_instance_ = new AuthResponse();
+  AuthError::default_instance_ = new AuthError();
+  DeviceAuthMessage::default_instance_ = new DeviceAuthMessage();
+  CastMessage::default_instance_->InitAsDefaultInstance();
+  AuthChallenge::default_instance_->InitAsDefaultInstance();
+  AuthResponse::default_instance_->InitAsDefaultInstance();
+  AuthError::default_instance_->InitAsDefaultInstance();
+  DeviceAuthMessage::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_cast_5fchannel_2eproto);
+}
+
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_cast_5fchannel_2eproto_once_);
+void protobuf_AddDesc_cast_5fchannel_2eproto() {
+  ::google::protobuf::::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_cast_5fchannel_2eproto_once_,
+                 &protobuf_AddDesc_cast_5fchannel_2eproto_impl);
+}
+#else
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_cast_5fchannel_2eproto {
+  StaticDescriptorInitializer_cast_5fchannel_2eproto() {
+    protobuf_AddDesc_cast_5fchannel_2eproto();
+  }
+} static_descriptor_initializer_cast_5fchannel_2eproto_;
+#endif
+
+// ===================================================================
+
+bool CastMessage_ProtocolVersion_IsValid(int value) {
+  switch(value) {
+    case 0:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const CastMessage_ProtocolVersion CastMessage::CASTV2_1_0;
+const CastMessage_ProtocolVersion CastMessage::ProtocolVersion_MIN;
+const CastMessage_ProtocolVersion CastMessage::ProtocolVersion_MAX;
+const int CastMessage::ProtocolVersion_ARRAYSIZE;
+#endif  // _MSC_VER
+bool CastMessage_PayloadType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const CastMessage_PayloadType CastMessage::STRING;
+const CastMessage_PayloadType CastMessage::BINARY;
+const CastMessage_PayloadType CastMessage::PayloadType_MIN;
+const CastMessage_PayloadType CastMessage::PayloadType_MAX;
+const int CastMessage::PayloadType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int CastMessage::kProtocolVersionFieldNumber;
+const int CastMessage::kSourceIdFieldNumber;
+const int CastMessage::kDestinationIdFieldNumber;
+const int CastMessage::kNamespaceFieldNumber;
+const int CastMessage::kPayloadTypeFieldNumber;
+const int CastMessage::kPayloadUtf8FieldNumber;
+const int CastMessage::kPayloadBinaryFieldNumber;
+#endif  // !_MSC_VER
+
+CastMessage::CastMessage()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void CastMessage::InitAsDefaultInstance() {
+}
+
+CastMessage::CastMessage(const CastMessage& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void CastMessage::SharedCtor() {
+  _cached_size_ = 0;
+  protocol_version_ = 0;
+  source_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  destination_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  namespace__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  payload_type_ = 0;
+  payload_utf8_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  payload_binary_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CastMessage::~CastMessage() {
+  SharedDtor();
+}
+
+void CastMessage::SharedDtor() {
+  if (source_id_ != &::google::protobuf::internal::kEmptyString) {
+    delete source_id_;
+  }
+  if (destination_id_ != &::google::protobuf::internal::kEmptyString) {
+    delete destination_id_;
+  }
+  if (namespace__ != &::google::protobuf::internal::kEmptyString) {
+    delete namespace__;
+  }
+  if (payload_utf8_ != &::google::protobuf::internal::kEmptyString) {
+    delete payload_utf8_;
+  }
+  if (payload_binary_ != &::google::protobuf::internal::kEmptyString) {
+    delete payload_binary_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void CastMessage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const CastMessage& CastMessage::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_cast_5fchannel_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_cast_5fchannel_2eproto();
+#endif
+  return *default_instance_;
+}
+
+CastMessage* CastMessage::default_instance_ = NULL;
+
+CastMessage* CastMessage::New() const {
+  return new CastMessage;
+}
+
+void CastMessage::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    protocol_version_ = 0;
+    if (has_source_id()) {
+      if (source_id_ != &::google::protobuf::internal::kEmptyString) {
+        source_id_->clear();
+      }
+    }
+    if (has_destination_id()) {
+      if (destination_id_ != &::google::protobuf::internal::kEmptyString) {
+        destination_id_->clear();
+      }
+    }
+    if (has_namespace_()) {
+      if (namespace__ != &::google::protobuf::internal::kEmptyString) {
+        namespace__->clear();
+      }
+    }
+    payload_type_ = 0;
+    if (has_payload_utf8()) {
+      if (payload_utf8_ != &::google::protobuf::internal::kEmptyString) {
+        payload_utf8_->clear();
+      }
+    }
+    if (has_payload_binary()) {
+      if (payload_binary_ != &::google::protobuf::internal::kEmptyString) {
+        payload_binary_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool CastMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::castchannel::CastMessage_ProtocolVersion_IsValid(value)) {
+            set_protocol_version(static_cast< ::castchannel::CastMessage_ProtocolVersion >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_source_id;
+        break;
+      }
+
+      // required string source_id = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_source_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_source_id()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_destination_id;
+        break;
+      }
+
+      // required string destination_id = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_destination_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_destination_id()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(34)) goto parse_namespace;
+        break;
+      }
+
+      // required string namespace = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_namespace:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_namespace_()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_payload_type;
+        break;
+      }
+
+      // required .castchannel.CastMessage.PayloadType payload_type = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         parse_payload_type:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::castchannel::CastMessage_PayloadType_IsValid(value)) {
+            set_payload_type(static_cast< ::castchannel::CastMessage_PayloadType >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(50)) goto parse_payload_utf8;
+        break;
+      }
+
+      // optional string payload_utf8 = 6;
+      case 6: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_payload_utf8:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_payload_utf8()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(58)) goto parse_payload_binary;
+        break;
+      }
+
+      // optional bytes payload_binary = 7;
+      case 7: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_payload_binary:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_payload_binary()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void CastMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
+  if (has_protocol_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->protocol_version(), output);
+  }
+
+  // required string source_id = 2;
+  if (has_source_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->source_id(), output);
+  }
+
+  // required string destination_id = 3;
+  if (has_destination_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->destination_id(), output);
+  }
+
+  // required string namespace = 4;
+  if (has_namespace_()) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->namespace_(), output);
+  }
+
+  // required .castchannel.CastMessage.PayloadType payload_type = 5;
+  if (has_payload_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      5, this->payload_type(), output);
+  }
+
+  // optional string payload_utf8 = 6;
+  if (has_payload_utf8()) {
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      6, this->payload_utf8(), output);
+  }
+
+  // optional bytes payload_binary = 7;
+  if (has_payload_binary()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      7, this->payload_binary(), output);
+  }
+
+}
+
+int CastMessage::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
+    if (has_protocol_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->protocol_version());
+    }
+
+    // required string source_id = 2;
+    if (has_source_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->source_id());
+    }
+
+    // required string destination_id = 3;
+    if (has_destination_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->destination_id());
+    }
+
+    // required string namespace = 4;
+    if (has_namespace_()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->namespace_());
+    }
+
+    // required .castchannel.CastMessage.PayloadType payload_type = 5;
+    if (has_payload_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->payload_type());
+    }
+
+    // optional string payload_utf8 = 6;
+    if (has_payload_utf8()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->payload_utf8());
+    }
+
+    // optional bytes payload_binary = 7;
+    if (has_payload_binary()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->payload_binary());
+    }
+
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CastMessage::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const CastMessage*>(&from));
+}
+
+void CastMessage::MergeFrom(const CastMessage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_protocol_version()) {
+      set_protocol_version(from.protocol_version());
+    }
+    if (from.has_source_id()) {
+      set_source_id(from.source_id());
+    }
+    if (from.has_destination_id()) {
+      set_destination_id(from.destination_id());
+    }
+    if (from.has_namespace_()) {
+      set_namespace_(from.namespace_());
+    }
+    if (from.has_payload_type()) {
+      set_payload_type(from.payload_type());
+    }
+    if (from.has_payload_utf8()) {
+      set_payload_utf8(from.payload_utf8());
+    }
+    if (from.has_payload_binary()) {
+      set_payload_binary(from.payload_binary());
+    }
+  }
+}
+
+void CastMessage::CopyFrom(const CastMessage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CastMessage::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000001f) != 0x0000001f) return false;
+
+  return true;
+}
+
+void CastMessage::Swap(CastMessage* other) {
+  if (other != this) {
+    std::swap(protocol_version_, other->protocol_version_);
+    std::swap(source_id_, other->source_id_);
+    std::swap(destination_id_, other->destination_id_);
+    std::swap(namespace__, other->namespace__);
+    std::swap(payload_type_, other->payload_type_);
+    std::swap(payload_utf8_, other->payload_utf8_);
+    std::swap(payload_binary_, other->payload_binary_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string CastMessage::GetTypeName() const {
+  return "castchannel.CastMessage";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+AuthChallenge::AuthChallenge()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void AuthChallenge::InitAsDefaultInstance() {
+}
+
+AuthChallenge::AuthChallenge(const AuthChallenge& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void AuthChallenge::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AuthChallenge::~AuthChallenge() {
+  SharedDtor();
+}
+
+void AuthChallenge::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void AuthChallenge::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const AuthChallenge& AuthChallenge::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_cast_5fchannel_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_cast_5fchannel_2eproto();
+#endif
+  return *default_instance_;
+}
+
+AuthChallenge* AuthChallenge::default_instance_ = NULL;
+
+AuthChallenge* AuthChallenge::New() const {
+  return new AuthChallenge;
+}
+
+void AuthChallenge::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool AuthChallenge::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      return true;
+    }
+    DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+  }
+  return true;
+#undef DO_
+}
+
+void AuthChallenge::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+}
+
+int AuthChallenge::ByteSize() const {
+  int total_size = 0;
+
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AuthChallenge::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const AuthChallenge*>(&from));
+}
+
+void AuthChallenge::MergeFrom(const AuthChallenge& from) {
+  GOOGLE_CHECK_NE(&from, this);
+}
+
+void AuthChallenge::CopyFrom(const AuthChallenge& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AuthChallenge::IsInitialized() const {
+
+  return true;
+}
+
+void AuthChallenge::Swap(AuthChallenge* other) {
+  if (other != this) {
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string AuthChallenge::GetTypeName() const {
+  return "castchannel.AuthChallenge";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AuthResponse::kSignatureFieldNumber;
+const int AuthResponse::kClientAuthCertificateFieldNumber;
+#endif  // !_MSC_VER
+
+AuthResponse::AuthResponse()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void AuthResponse::InitAsDefaultInstance() {
+}
+
+AuthResponse::AuthResponse(const AuthResponse& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void AuthResponse::SharedCtor() {
+  _cached_size_ = 0;
+  signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  client_auth_certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AuthResponse::~AuthResponse() {
+  SharedDtor();
+}
+
+void AuthResponse::SharedDtor() {
+  if (signature_ != &::google::protobuf::internal::kEmptyString) {
+    delete signature_;
+  }
+  if (client_auth_certificate_ != &::google::protobuf::internal::kEmptyString) {
+    delete client_auth_certificate_;
+  }
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void AuthResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const AuthResponse& AuthResponse::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_cast_5fchannel_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_cast_5fchannel_2eproto();
+#endif
+  return *default_instance_;
+}
+
+AuthResponse* AuthResponse::default_instance_ = NULL;
+
+AuthResponse* AuthResponse::New() const {
+  return new AuthResponse;
+}
+
+void AuthResponse::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_signature()) {
+      if (signature_ != &::google::protobuf::internal::kEmptyString) {
+        signature_->clear();
+      }
+    }
+    if (has_client_auth_certificate()) {
+      if (client_auth_certificate_ != &::google::protobuf::internal::kEmptyString) {
+        client_auth_certificate_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool AuthResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bytes signature = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_signature()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_client_auth_certificate;
+        break;
+      }
+
+      // required bytes client_auth_certificate = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_client_auth_certificate:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_client_auth_certificate()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void AuthResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required bytes signature = 1;
+  if (has_signature()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      1, this->signature(), output);
+  }
+
+  // required bytes client_auth_certificate = 2;
+  if (has_client_auth_certificate()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytes(
+      2, this->client_auth_certificate(), output);
+  }
+
+}
+
+int AuthResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required bytes signature = 1;
+    if (has_signature()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->signature());
+    }
+
+    // required bytes client_auth_certificate = 2;
+    if (has_client_auth_certificate()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->client_auth_certificate());
+    }
+
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AuthResponse::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const AuthResponse*>(&from));
+}
+
+void AuthResponse::MergeFrom(const AuthResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_signature()) {
+      set_signature(from.signature());
+    }
+    if (from.has_client_auth_certificate()) {
+      set_client_auth_certificate(from.client_auth_certificate());
+    }
+  }
+}
+
+void AuthResponse::CopyFrom(const AuthResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AuthResponse::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void AuthResponse::Swap(AuthResponse* other) {
+  if (other != this) {
+    std::swap(signature_, other->signature_);
+    std::swap(client_auth_certificate_, other->client_auth_certificate_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string AuthResponse::GetTypeName() const {
+  return "castchannel.AuthResponse";
+}
+
+
+// ===================================================================
+
+bool AuthError_ErrorType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const AuthError_ErrorType AuthError::INTERNAL_ERROR;
+const AuthError_ErrorType AuthError::NO_TLS;
+const AuthError_ErrorType AuthError::ErrorType_MIN;
+const AuthError_ErrorType AuthError::ErrorType_MAX;
+const int AuthError::ErrorType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int AuthError::kErrorTypeFieldNumber;
+#endif  // !_MSC_VER
+
+AuthError::AuthError()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void AuthError::InitAsDefaultInstance() {
+}
+
+AuthError::AuthError(const AuthError& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void AuthError::SharedCtor() {
+  _cached_size_ = 0;
+  error_type_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AuthError::~AuthError() {
+  SharedDtor();
+}
+
+void AuthError::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+  }
+}
+
+void AuthError::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const AuthError& AuthError::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_cast_5fchannel_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_cast_5fchannel_2eproto();
+#endif
+  return *default_instance_;
+}
+
+AuthError* AuthError::default_instance_ = NULL;
+
+AuthError* AuthError::New() const {
+  return new AuthError;
+}
+
+void AuthError::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    error_type_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool AuthError::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .castchannel.AuthError.ErrorType error_type = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::castchannel::AuthError_ErrorType_IsValid(value)) {
+            set_error_type(static_cast< ::castchannel::AuthError_ErrorType >(value));
+          }
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void AuthError::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // required .castchannel.AuthError.ErrorType error_type = 1;
+  if (has_error_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->error_type(), output);
+  }
+
+}
+
+int AuthError::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .castchannel.AuthError.ErrorType error_type = 1;
+    if (has_error_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->error_type());
+    }
+
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AuthError::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const AuthError*>(&from));
+}
+
+void AuthError::MergeFrom(const AuthError& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_error_type()) {
+      set_error_type(from.error_type());
+    }
+  }
+}
+
+void AuthError::CopyFrom(const AuthError& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AuthError::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void AuthError::Swap(AuthError* other) {
+  if (other != this) {
+    std::swap(error_type_, other->error_type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string AuthError::GetTypeName() const {
+  return "castchannel.AuthError";
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DeviceAuthMessage::kChallengeFieldNumber;
+const int DeviceAuthMessage::kResponseFieldNumber;
+const int DeviceAuthMessage::kErrorFieldNumber;
+#endif  // !_MSC_VER
+
+DeviceAuthMessage::DeviceAuthMessage()
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+}
+
+void DeviceAuthMessage::InitAsDefaultInstance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  challenge_ = const_cast< ::castchannel::AuthChallenge*>(
+      ::castchannel::AuthChallenge::internal_default_instance());
+#else
+  challenge_ = const_cast< ::castchannel::AuthChallenge*>(&::castchannel::AuthChallenge::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  response_ = const_cast< ::castchannel::AuthResponse*>(
+      ::castchannel::AuthResponse::internal_default_instance());
+#else
+  response_ = const_cast< ::castchannel::AuthResponse*>(&::castchannel::AuthResponse::default_instance());
+#endif
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  error_ = const_cast< ::castchannel::AuthError*>(
+      ::castchannel::AuthError::internal_default_instance());
+#else
+  error_ = const_cast< ::castchannel::AuthError*>(&::castchannel::AuthError::default_instance());
+#endif
+}
+
+DeviceAuthMessage::DeviceAuthMessage(const DeviceAuthMessage& from)
+  : ::google::protobuf::MessageLite() {
+  SharedCtor();
+  MergeFrom(from);
+}
+
+void DeviceAuthMessage::SharedCtor() {
+  _cached_size_ = 0;
+  challenge_ = NULL;
+  response_ = NULL;
+  error_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DeviceAuthMessage::~DeviceAuthMessage() {
+  SharedDtor();
+}
+
+void DeviceAuthMessage::SharedDtor() {
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  if (this != &default_instance()) {
+  #else
+  if (this != default_instance_) {
+  #endif
+    delete challenge_;
+    delete response_;
+    delete error_;
+  }
+}
+
+void DeviceAuthMessage::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const DeviceAuthMessage& DeviceAuthMessage::default_instance() {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  protobuf_AddDesc_cast_5fchannel_2eproto();
+#else
+  if (default_instance_ == NULL) protobuf_AddDesc_cast_5fchannel_2eproto();
+#endif
+  return *default_instance_;
+}
+
+DeviceAuthMessage* DeviceAuthMessage::default_instance_ = NULL;
+
+DeviceAuthMessage* DeviceAuthMessage::New() const {
+  return new DeviceAuthMessage;
+}
+
+void DeviceAuthMessage::Clear() {
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (has_challenge()) {
+      if (challenge_ != NULL) challenge_->::castchannel::AuthChallenge::Clear();
+    }
+    if (has_response()) {
+      if (response_ != NULL) response_->::castchannel::AuthResponse::Clear();
+    }
+    if (has_error()) {
+      if (error_ != NULL) error_->::castchannel::AuthError::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+bool DeviceAuthMessage::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
+  ::google::protobuf::uint32 tag;
+  while ((tag = input->ReadTag()) != 0) {
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .castchannel.AuthChallenge challenge = 1;
+      case 1: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_challenge()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(18)) goto parse_response;
+        break;
+      }
+
+      // optional .castchannel.AuthResponse response = 2;
+      case 2: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_response:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_response()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectTag(26)) goto parse_error;
+        break;
+      }
+
+      // optional .castchannel.AuthError error = 3;
+      case 3: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_error()));
+        } else {
+          goto handle_uninterpreted;
+        }
+        if (input->ExpectAtEnd()) return true;
+        break;
+      }
+
+      default: {
+      handle_uninterpreted:
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          return true;
+        }
+        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        break;
+      }
+    }
+  }
+  return true;
+#undef DO_
+}
+
+void DeviceAuthMessage::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // optional .castchannel.AuthChallenge challenge = 1;
+  if (has_challenge()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      1, this->challenge(), output);
+  }
+
+  // optional .castchannel.AuthResponse response = 2;
+  if (has_response()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      2, this->response(), output);
+  }
+
+  // optional .castchannel.AuthError error = 3;
+  if (has_error()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+      3, this->error(), output);
+  }
+
+}
+
+int DeviceAuthMessage::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .castchannel.AuthChallenge challenge = 1;
+    if (has_challenge()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->challenge());
+    }
+
+    // optional .castchannel.AuthResponse response = 2;
+    if (has_response()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->response());
+    }
+
+    // optional .castchannel.AuthError error = 3;
+    if (has_error()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->error());
+    }
+
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DeviceAuthMessage::CheckTypeAndMergeFrom(
+    const ::google::protobuf::MessageLite& from) {
+  MergeFrom(*::google::protobuf::down_cast<const DeviceAuthMessage*>(&from));
+}
+
+void DeviceAuthMessage::MergeFrom(const DeviceAuthMessage& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_challenge()) {
+      mutable_challenge()->::castchannel::AuthChallenge::MergeFrom(from.challenge());
+    }
+    if (from.has_response()) {
+      mutable_response()->::castchannel::AuthResponse::MergeFrom(from.response());
+    }
+    if (from.has_error()) {
+      mutable_error()->::castchannel::AuthError::MergeFrom(from.error());
+    }
+  }
+}
+
+void DeviceAuthMessage::CopyFrom(const DeviceAuthMessage& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeviceAuthMessage::IsInitialized() const {
+
+  if (has_response()) {
+    if (!this->response().IsInitialized()) return false;
+  }
+  if (has_error()) {
+    if (!this->error().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DeviceAuthMessage::Swap(DeviceAuthMessage* other) {
+  if (other != this) {
+    std::swap(challenge_, other->challenge_);
+    std::swap(response_, other->response_);
+    std::swap(error_, other->error_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::std::string DeviceAuthMessage::GetTypeName() const {
+  return "castchannel.DeviceAuthMessage";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace castchannel
+
+// @@protoc_insertion_point(global_scope)
diff --git a/modules/stream_out/chromecast/cast_channel.pb.h b/modules/stream_out/chromecast/cast_channel.pb.h
new file mode 100644
index 0000000..66176fa
--- /dev/null
+++ b/modules/stream_out/chromecast/cast_channel.pb.h
@@ -0,0 +1,1357 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: cast_channel.proto
+// protoc --cpp_out=. cast_channel.proto
+
+#ifndef PROTOBUF_cast_5fchannel_2eproto__INCLUDED
+#define PROTOBUF_cast_5fchannel_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 2005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace castchannel {
+
+// Internal implementation detail -- do not call these.
+void  protobuf_AddDesc_cast_5fchannel_2eproto();
+void protobuf_AssignDesc_cast_5fchannel_2eproto();
+void protobuf_ShutdownFile_cast_5fchannel_2eproto();
+
+class CastMessage;
+class AuthChallenge;
+class AuthResponse;
+class AuthError;
+class DeviceAuthMessage;
+
+enum CastMessage_ProtocolVersion {
+  CastMessage_ProtocolVersion_CASTV2_1_0 = 0
+};
+bool CastMessage_ProtocolVersion_IsValid(int value);
+const CastMessage_ProtocolVersion CastMessage_ProtocolVersion_ProtocolVersion_MIN = CastMessage_ProtocolVersion_CASTV2_1_0;
+const CastMessage_ProtocolVersion CastMessage_ProtocolVersion_ProtocolVersion_MAX = CastMessage_ProtocolVersion_CASTV2_1_0;
+const int CastMessage_ProtocolVersion_ProtocolVersion_ARRAYSIZE = CastMessage_ProtocolVersion_ProtocolVersion_MAX + 1;
+
+enum CastMessage_PayloadType {
+  CastMessage_PayloadType_STRING = 0,
+  CastMessage_PayloadType_BINARY = 1
+};
+bool CastMessage_PayloadType_IsValid(int value);
+const CastMessage_PayloadType CastMessage_PayloadType_PayloadType_MIN = CastMessage_PayloadType_STRING;
+const CastMessage_PayloadType CastMessage_PayloadType_PayloadType_MAX = CastMessage_PayloadType_BINARY;
+const int CastMessage_PayloadType_PayloadType_ARRAYSIZE = CastMessage_PayloadType_PayloadType_MAX + 1;
+
+enum AuthError_ErrorType {
+  AuthError_ErrorType_INTERNAL_ERROR = 0,
+  AuthError_ErrorType_NO_TLS = 1
+};
+bool AuthError_ErrorType_IsValid(int value);
+const AuthError_ErrorType AuthError_ErrorType_ErrorType_MIN = AuthError_ErrorType_INTERNAL_ERROR;
+const AuthError_ErrorType AuthError_ErrorType_ErrorType_MAX = AuthError_ErrorType_NO_TLS;
+const int AuthError_ErrorType_ErrorType_ARRAYSIZE = AuthError_ErrorType_ErrorType_MAX + 1;
+
+// ===================================================================
+
+class CastMessage : public ::google::protobuf::MessageLite {
+ public:
+  CastMessage();
+  virtual ~CastMessage();
+
+  CastMessage(const CastMessage& from);
+
+  inline CastMessage& operator=(const CastMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const CastMessage& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const CastMessage* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(CastMessage* other);
+
+  // implements Message ----------------------------------------------
+
+  CastMessage* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const CastMessage& from);
+  void MergeFrom(const CastMessage& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef CastMessage_ProtocolVersion ProtocolVersion;
+  static const ProtocolVersion CASTV2_1_0 = CastMessage_ProtocolVersion_CASTV2_1_0;
+  static inline bool ProtocolVersion_IsValid(int value) {
+    return CastMessage_ProtocolVersion_IsValid(value);
+  }
+  static const ProtocolVersion ProtocolVersion_MIN =
+    CastMessage_ProtocolVersion_ProtocolVersion_MIN;
+  static const ProtocolVersion ProtocolVersion_MAX =
+    CastMessage_ProtocolVersion_ProtocolVersion_MAX;
+  static const int ProtocolVersion_ARRAYSIZE =
+    CastMessage_ProtocolVersion_ProtocolVersion_ARRAYSIZE;
+
+  typedef CastMessage_PayloadType PayloadType;
+  static const PayloadType STRING = CastMessage_PayloadType_STRING;
+  static const PayloadType BINARY = CastMessage_PayloadType_BINARY;
+  static inline bool PayloadType_IsValid(int value) {
+    return CastMessage_PayloadType_IsValid(value);
+  }
+  static const PayloadType PayloadType_MIN =
+    CastMessage_PayloadType_PayloadType_MIN;
+  static const PayloadType PayloadType_MAX =
+    CastMessage_PayloadType_PayloadType_MAX;
+  static const int PayloadType_ARRAYSIZE =
+    CastMessage_PayloadType_PayloadType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
+  inline bool has_protocol_version() const;
+  inline void clear_protocol_version();
+  static const int kProtocolVersionFieldNumber = 1;
+  inline ::castchannel::CastMessage_ProtocolVersion protocol_version() const;
+  inline void set_protocol_version(::castchannel::CastMessage_ProtocolVersion value);
+
+  // required string source_id = 2;
+  inline bool has_source_id() const;
+  inline void clear_source_id();
+  static const int kSourceIdFieldNumber = 2;
+  inline const ::std::string& source_id() const;
+  inline void set_source_id(const ::std::string& value);
+  inline void set_source_id(const char* value);
+  inline void set_source_id(const char* value, size_t size);
+  inline ::std::string* mutable_source_id();
+  inline ::std::string* release_source_id();
+  inline void set_allocated_source_id(::std::string* source_id);
+
+  // required string destination_id = 3;
+  inline bool has_destination_id() const;
+  inline void clear_destination_id();
+  static const int kDestinationIdFieldNumber = 3;
+  inline const ::std::string& destination_id() const;
+  inline void set_destination_id(const ::std::string& value);
+  inline void set_destination_id(const char* value);
+  inline void set_destination_id(const char* value, size_t size);
+  inline ::std::string* mutable_destination_id();
+  inline ::std::string* release_destination_id();
+  inline void set_allocated_destination_id(::std::string* destination_id);
+
+  // required string namespace = 4;
+  inline bool has_namespace_() const;
+  inline void clear_namespace_();
+  static const int kNamespaceFieldNumber = 4;
+  inline const ::std::string& namespace_() const;
+  inline void set_namespace_(const ::std::string& value);
+  inline void set_namespace_(const char* value);
+  inline void set_namespace_(const char* value, size_t size);
+  inline ::std::string* mutable_namespace_();
+  inline ::std::string* release_namespace_();
+  inline void set_allocated_namespace_(::std::string* namespace_);
+
+  // required .castchannel.CastMessage.PayloadType payload_type = 5;
+  inline bool has_payload_type() const;
+  inline void clear_payload_type();
+  static const int kPayloadTypeFieldNumber = 5;
+  inline ::castchannel::CastMessage_PayloadType payload_type() const;
+  inline void set_payload_type(::castchannel::CastMessage_PayloadType value);
+
+  // optional string payload_utf8 = 6;
+  inline bool has_payload_utf8() const;
+  inline void clear_payload_utf8();
+  static const int kPayloadUtf8FieldNumber = 6;
+  inline const ::std::string& payload_utf8() const;
+  inline void set_payload_utf8(const ::std::string& value);
+  inline void set_payload_utf8(const char* value);
+  inline void set_payload_utf8(const char* value, size_t size);
+  inline ::std::string* mutable_payload_utf8();
+  inline ::std::string* release_payload_utf8();
+  inline void set_allocated_payload_utf8(::std::string* payload_utf8);
+
+  // optional bytes payload_binary = 7;
+  inline bool has_payload_binary() const;
+  inline void clear_payload_binary();
+  static const int kPayloadBinaryFieldNumber = 7;
+  inline const ::std::string& payload_binary() const;
+  inline void set_payload_binary(const ::std::string& value);
+  inline void set_payload_binary(const char* value);
+  inline void set_payload_binary(const void* value, size_t size);
+  inline ::std::string* mutable_payload_binary();
+  inline ::std::string* release_payload_binary();
+  inline void set_allocated_payload_binary(::std::string* payload_binary);
+
+  // @@protoc_insertion_point(class_scope:castchannel.CastMessage)
+ private:
+  inline void set_has_protocol_version();
+  inline void clear_has_protocol_version();
+  inline void set_has_source_id();
+  inline void clear_has_source_id();
+  inline void set_has_destination_id();
+  inline void clear_has_destination_id();
+  inline void set_has_namespace_();
+  inline void clear_has_namespace_();
+  inline void set_has_payload_type();
+  inline void clear_has_payload_type();
+  inline void set_has_payload_utf8();
+  inline void clear_has_payload_utf8();
+  inline void set_has_payload_binary();
+  inline void clear_has_payload_binary();
+
+  ::std::string* source_id_;
+  ::std::string* destination_id_;
+  int protocol_version_;
+  int payload_type_;
+  ::std::string* namespace__;
+  ::std::string* payload_utf8_;
+  ::std::string* payload_binary_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_cast_5fchannel_2eproto();
+  friend void protobuf_ShutdownFile_cast_5fchannel_2eproto();
+
+  void InitAsDefaultInstance();
+  static CastMessage* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class AuthChallenge : public ::google::protobuf::MessageLite {
+ public:
+  AuthChallenge();
+  virtual ~AuthChallenge();
+
+  AuthChallenge(const AuthChallenge& from);
+
+  inline AuthChallenge& operator=(const AuthChallenge& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const AuthChallenge& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const AuthChallenge* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(AuthChallenge* other);
+
+  // implements Message ----------------------------------------------
+
+  AuthChallenge* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const AuthChallenge& from);
+  void MergeFrom(const AuthChallenge& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:castchannel.AuthChallenge)
+ private:
+
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[1];
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_cast_5fchannel_2eproto();
+  friend void protobuf_ShutdownFile_cast_5fchannel_2eproto();
+
+  void InitAsDefaultInstance();
+  static AuthChallenge* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class AuthResponse : public ::google::protobuf::MessageLite {
+ public:
+  AuthResponse();
+  virtual ~AuthResponse();
+
+  AuthResponse(const AuthResponse& from);
+
+  inline AuthResponse& operator=(const AuthResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const AuthResponse& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const AuthResponse* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(AuthResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  AuthResponse* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const AuthResponse& from);
+  void MergeFrom(const AuthResponse& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required bytes signature = 1;
+  inline bool has_signature() const;
+  inline void clear_signature();
+  static const int kSignatureFieldNumber = 1;
+  inline const ::std::string& signature() const;
+  inline void set_signature(const ::std::string& value);
+  inline void set_signature(const char* value);
+  inline void set_signature(const void* value, size_t size);
+  inline ::std::string* mutable_signature();
+  inline ::std::string* release_signature();
+  inline void set_allocated_signature(::std::string* signature);
+
+  // required bytes client_auth_certificate = 2;
+  inline bool has_client_auth_certificate() const;
+  inline void clear_client_auth_certificate();
+  static const int kClientAuthCertificateFieldNumber = 2;
+  inline const ::std::string& client_auth_certificate() const;
+  inline void set_client_auth_certificate(const ::std::string& value);
+  inline void set_client_auth_certificate(const char* value);
+  inline void set_client_auth_certificate(const void* value, size_t size);
+  inline ::std::string* mutable_client_auth_certificate();
+  inline ::std::string* release_client_auth_certificate();
+  inline void set_allocated_client_auth_certificate(::std::string* client_auth_certificate);
+
+  // @@protoc_insertion_point(class_scope:castchannel.AuthResponse)
+ private:
+  inline void set_has_signature();
+  inline void clear_has_signature();
+  inline void set_has_client_auth_certificate();
+  inline void clear_has_client_auth_certificate();
+
+  ::std::string* signature_;
+  ::std::string* client_auth_certificate_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_cast_5fchannel_2eproto();
+  friend void protobuf_ShutdownFile_cast_5fchannel_2eproto();
+
+  void InitAsDefaultInstance();
+  static AuthResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class AuthError : public ::google::protobuf::MessageLite {
+ public:
+  AuthError();
+  virtual ~AuthError();
+
+  AuthError(const AuthError& from);
+
+  inline AuthError& operator=(const AuthError& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const AuthError& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const AuthError* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(AuthError* other);
+
+  // implements Message ----------------------------------------------
+
+  AuthError* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const AuthError& from);
+  void MergeFrom(const AuthError& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef AuthError_ErrorType ErrorType;
+  static const ErrorType INTERNAL_ERROR = AuthError_ErrorType_INTERNAL_ERROR;
+  static const ErrorType NO_TLS = AuthError_ErrorType_NO_TLS;
+  static inline bool ErrorType_IsValid(int value) {
+    return AuthError_ErrorType_IsValid(value);
+  }
+  static const ErrorType ErrorType_MIN =
+    AuthError_ErrorType_ErrorType_MIN;
+  static const ErrorType ErrorType_MAX =
+    AuthError_ErrorType_ErrorType_MAX;
+  static const int ErrorType_ARRAYSIZE =
+    AuthError_ErrorType_ErrorType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // required .castchannel.AuthError.ErrorType error_type = 1;
+  inline bool has_error_type() const;
+  inline void clear_error_type();
+  static const int kErrorTypeFieldNumber = 1;
+  inline ::castchannel::AuthError_ErrorType error_type() const;
+  inline void set_error_type(::castchannel::AuthError_ErrorType value);
+
+  // @@protoc_insertion_point(class_scope:castchannel.AuthError)
+ private:
+  inline void set_has_error_type();
+  inline void clear_has_error_type();
+
+  int error_type_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_cast_5fchannel_2eproto();
+  friend void protobuf_ShutdownFile_cast_5fchannel_2eproto();
+
+  void InitAsDefaultInstance();
+  static AuthError* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class DeviceAuthMessage : public ::google::protobuf::MessageLite {
+ public:
+  DeviceAuthMessage();
+  virtual ~DeviceAuthMessage();
+
+  DeviceAuthMessage(const DeviceAuthMessage& from);
+
+  inline DeviceAuthMessage& operator=(const DeviceAuthMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  static const DeviceAuthMessage& default_instance();
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  // Returns the internal default instance pointer. This function can
+  // return NULL thus should not be used by the user. This is intended
+  // for Protobuf internal code. Please use default_instance() declared
+  // above instead.
+  static inline const DeviceAuthMessage* internal_default_instance() {
+    return default_instance_;
+  }
+  #endif
+
+  void Swap(DeviceAuthMessage* other);
+
+  // implements Message ----------------------------------------------
+
+  DeviceAuthMessage* New() const;
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const DeviceAuthMessage& from);
+  void MergeFrom(const DeviceAuthMessage& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+
+  ::std::string GetTypeName() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .castchannel.AuthChallenge challenge = 1;
+  inline bool has_challenge() const;
+  inline void clear_challenge();
+  static const int kChallengeFieldNumber = 1;
+  inline const ::castchannel::AuthChallenge& challenge() const;
+  inline ::castchannel::AuthChallenge* mutable_challenge();
+  inline ::castchannel::AuthChallenge* release_challenge();
+  inline void set_allocated_challenge(::castchannel::AuthChallenge* challenge);
+
+  // optional .castchannel.AuthResponse response = 2;
+  inline bool has_response() const;
+  inline void clear_response();
+  static const int kResponseFieldNumber = 2;
+  inline const ::castchannel::AuthResponse& response() const;
+  inline ::castchannel::AuthResponse* mutable_response();
+  inline ::castchannel::AuthResponse* release_response();
+  inline void set_allocated_response(::castchannel::AuthResponse* response);
+
+  // optional .castchannel.AuthError error = 3;
+  inline bool has_error() const;
+  inline void clear_error();
+  static const int kErrorFieldNumber = 3;
+  inline const ::castchannel::AuthError& error() const;
+  inline ::castchannel::AuthError* mutable_error();
+  inline ::castchannel::AuthError* release_error();
+  inline void set_allocated_error(::castchannel::AuthError* error);
+
+  // @@protoc_insertion_point(class_scope:castchannel.DeviceAuthMessage)
+ private:
+  inline void set_has_challenge();
+  inline void clear_has_challenge();
+  inline void set_has_response();
+  inline void clear_has_response();
+  inline void set_has_error();
+  inline void clear_has_error();
+
+  ::castchannel::AuthChallenge* challenge_;
+  ::castchannel::AuthResponse* response_;
+  ::castchannel::AuthError* error_;
+
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+
+  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto_impl();
+  #else
+  friend void  protobuf_AddDesc_cast_5fchannel_2eproto();
+  #endif
+  friend void protobuf_AssignDesc_cast_5fchannel_2eproto();
+  friend void protobuf_ShutdownFile_cast_5fchannel_2eproto();
+
+  void InitAsDefaultInstance();
+  static DeviceAuthMessage* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+// CastMessage
+
+// required .castchannel.CastMessage.ProtocolVersion protocol_version = 1;
+inline bool CastMessage::has_protocol_version() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CastMessage::set_has_protocol_version() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CastMessage::clear_has_protocol_version() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CastMessage::clear_protocol_version() {
+  protocol_version_ = 0;
+  clear_has_protocol_version();
+}
+inline ::castchannel::CastMessage_ProtocolVersion CastMessage::protocol_version() const {
+  return static_cast< ::castchannel::CastMessage_ProtocolVersion >(protocol_version_);
+}
+inline void CastMessage::set_protocol_version(::castchannel::CastMessage_ProtocolVersion value) {
+  assert(::castchannel::CastMessage_ProtocolVersion_IsValid(value));
+  set_has_protocol_version();
+  protocol_version_ = value;
+}
+
+// required string source_id = 2;
+inline bool CastMessage::has_source_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CastMessage::set_has_source_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CastMessage::clear_has_source_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CastMessage::clear_source_id() {
+  if (source_id_ != &::google::protobuf::internal::kEmptyString) {
+    source_id_->clear();
+  }
+  clear_has_source_id();
+}
+inline const ::std::string& CastMessage::source_id() const {
+  return *source_id_;
+}
+inline void CastMessage::set_source_id(const ::std::string& value) {
+  set_has_source_id();
+  if (source_id_ == &::google::protobuf::internal::kEmptyString) {
+    source_id_ = new ::std::string;
+  }
+  source_id_->assign(value);
+}
+inline void CastMessage::set_source_id(const char* value) {
+  set_has_source_id();
+  if (source_id_ == &::google::protobuf::internal::kEmptyString) {
+    source_id_ = new ::std::string;
+  }
+  source_id_->assign(value);
+}
+inline void CastMessage::set_source_id(const char* value, size_t size) {
+  set_has_source_id();
+  if (source_id_ == &::google::protobuf::internal::kEmptyString) {
+    source_id_ = new ::std::string;
+  }
+  source_id_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CastMessage::mutable_source_id() {
+  set_has_source_id();
+  if (source_id_ == &::google::protobuf::internal::kEmptyString) {
+    source_id_ = new ::std::string;
+  }
+  return source_id_;
+}
+inline ::std::string* CastMessage::release_source_id() {
+  clear_has_source_id();
+  if (source_id_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = source_id_;
+    source_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CastMessage::set_allocated_source_id(::std::string* source_id) {
+  if (source_id_ != &::google::protobuf::internal::kEmptyString) {
+    delete source_id_;
+  }
+  if (source_id) {
+    set_has_source_id();
+    source_id_ = source_id;
+  } else {
+    clear_has_source_id();
+    source_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// required string destination_id = 3;
+inline bool CastMessage::has_destination_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CastMessage::set_has_destination_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CastMessage::clear_has_destination_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CastMessage::clear_destination_id() {
+  if (destination_id_ != &::google::protobuf::internal::kEmptyString) {
+    destination_id_->clear();
+  }
+  clear_has_destination_id();
+}
+inline const ::std::string& CastMessage::destination_id() const {
+  return *destination_id_;
+}
+inline void CastMessage::set_destination_id(const ::std::string& value) {
+  set_has_destination_id();
+  if (destination_id_ == &::google::protobuf::internal::kEmptyString) {
+    destination_id_ = new ::std::string;
+  }
+  destination_id_->assign(value);
+}
+inline void CastMessage::set_destination_id(const char* value) {
+  set_has_destination_id();
+  if (destination_id_ == &::google::protobuf::internal::kEmptyString) {
+    destination_id_ = new ::std::string;
+  }
+  destination_id_->assign(value);
+}
+inline void CastMessage::set_destination_id(const char* value, size_t size) {
+  set_has_destination_id();
+  if (destination_id_ == &::google::protobuf::internal::kEmptyString) {
+    destination_id_ = new ::std::string;
+  }
+  destination_id_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CastMessage::mutable_destination_id() {
+  set_has_destination_id();
+  if (destination_id_ == &::google::protobuf::internal::kEmptyString) {
+    destination_id_ = new ::std::string;
+  }
+  return destination_id_;
+}
+inline ::std::string* CastMessage::release_destination_id() {
+  clear_has_destination_id();
+  if (destination_id_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = destination_id_;
+    destination_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CastMessage::set_allocated_destination_id(::std::string* destination_id) {
+  if (destination_id_ != &::google::protobuf::internal::kEmptyString) {
+    delete destination_id_;
+  }
+  if (destination_id) {
+    set_has_destination_id();
+    destination_id_ = destination_id;
+  } else {
+    clear_has_destination_id();
+    destination_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// required string namespace = 4;
+inline bool CastMessage::has_namespace_() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CastMessage::set_has_namespace_() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CastMessage::clear_has_namespace_() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CastMessage::clear_namespace_() {
+  if (namespace__ != &::google::protobuf::internal::kEmptyString) {
+    namespace__->clear();
+  }
+  clear_has_namespace_();
+}
+inline const ::std::string& CastMessage::namespace_() const {
+  return *namespace__;
+}
+inline void CastMessage::set_namespace_(const ::std::string& value) {
+  set_has_namespace_();
+  if (namespace__ == &::google::protobuf::internal::kEmptyString) {
+    namespace__ = new ::std::string;
+  }
+  namespace__->assign(value);
+}
+inline void CastMessage::set_namespace_(const char* value) {
+  set_has_namespace_();
+  if (namespace__ == &::google::protobuf::internal::kEmptyString) {
+    namespace__ = new ::std::string;
+  }
+  namespace__->assign(value);
+}
+inline void CastMessage::set_namespace_(const char* value, size_t size) {
+  set_has_namespace_();
+  if (namespace__ == &::google::protobuf::internal::kEmptyString) {
+    namespace__ = new ::std::string;
+  }
+  namespace__->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CastMessage::mutable_namespace_() {
+  set_has_namespace_();
+  if (namespace__ == &::google::protobuf::internal::kEmptyString) {
+    namespace__ = new ::std::string;
+  }
+  return namespace__;
+}
+inline ::std::string* CastMessage::release_namespace_() {
+  clear_has_namespace_();
+  if (namespace__ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = namespace__;
+    namespace__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CastMessage::set_allocated_namespace_(::std::string* namespace_) {
+  if (namespace__ != &::google::protobuf::internal::kEmptyString) {
+    delete namespace__;
+  }
+  if (namespace_) {
+    set_has_namespace_();
+    namespace__ = namespace_;
+  } else {
+    clear_has_namespace_();
+    namespace__ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// required .castchannel.CastMessage.PayloadType payload_type = 5;
+inline bool CastMessage::has_payload_type() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void CastMessage::set_has_payload_type() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void CastMessage::clear_has_payload_type() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void CastMessage::clear_payload_type() {
+  payload_type_ = 0;
+  clear_has_payload_type();
+}
+inline ::castchannel::CastMessage_PayloadType CastMessage::payload_type() const {
+  return static_cast< ::castchannel::CastMessage_PayloadType >(payload_type_);
+}
+inline void CastMessage::set_payload_type(::castchannel::CastMessage_PayloadType value) {
+  assert(::castchannel::CastMessage_PayloadType_IsValid(value));
+  set_has_payload_type();
+  payload_type_ = value;
+}
+
+// optional string payload_utf8 = 6;
+inline bool CastMessage::has_payload_utf8() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void CastMessage::set_has_payload_utf8() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void CastMessage::clear_has_payload_utf8() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void CastMessage::clear_payload_utf8() {
+  if (payload_utf8_ != &::google::protobuf::internal::kEmptyString) {
+    payload_utf8_->clear();
+  }
+  clear_has_payload_utf8();
+}
+inline const ::std::string& CastMessage::payload_utf8() const {
+  return *payload_utf8_;
+}
+inline void CastMessage::set_payload_utf8(const ::std::string& value) {
+  set_has_payload_utf8();
+  if (payload_utf8_ == &::google::protobuf::internal::kEmptyString) {
+    payload_utf8_ = new ::std::string;
+  }
+  payload_utf8_->assign(value);
+}
+inline void CastMessage::set_payload_utf8(const char* value) {
+  set_has_payload_utf8();
+  if (payload_utf8_ == &::google::protobuf::internal::kEmptyString) {
+    payload_utf8_ = new ::std::string;
+  }
+  payload_utf8_->assign(value);
+}
+inline void CastMessage::set_payload_utf8(const char* value, size_t size) {
+  set_has_payload_utf8();
+  if (payload_utf8_ == &::google::protobuf::internal::kEmptyString) {
+    payload_utf8_ = new ::std::string;
+  }
+  payload_utf8_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CastMessage::mutable_payload_utf8() {
+  set_has_payload_utf8();
+  if (payload_utf8_ == &::google::protobuf::internal::kEmptyString) {
+    payload_utf8_ = new ::std::string;
+  }
+  return payload_utf8_;
+}
+inline ::std::string* CastMessage::release_payload_utf8() {
+  clear_has_payload_utf8();
+  if (payload_utf8_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = payload_utf8_;
+    payload_utf8_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CastMessage::set_allocated_payload_utf8(::std::string* payload_utf8) {
+  if (payload_utf8_ != &::google::protobuf::internal::kEmptyString) {
+    delete payload_utf8_;
+  }
+  if (payload_utf8) {
+    set_has_payload_utf8();
+    payload_utf8_ = payload_utf8;
+  } else {
+    clear_has_payload_utf8();
+    payload_utf8_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// optional bytes payload_binary = 7;
+inline bool CastMessage::has_payload_binary() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void CastMessage::set_has_payload_binary() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void CastMessage::clear_has_payload_binary() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void CastMessage::clear_payload_binary() {
+  if (payload_binary_ != &::google::protobuf::internal::kEmptyString) {
+    payload_binary_->clear();
+  }
+  clear_has_payload_binary();
+}
+inline const ::std::string& CastMessage::payload_binary() const {
+  return *payload_binary_;
+}
+inline void CastMessage::set_payload_binary(const ::std::string& value) {
+  set_has_payload_binary();
+  if (payload_binary_ == &::google::protobuf::internal::kEmptyString) {
+    payload_binary_ = new ::std::string;
+  }
+  payload_binary_->assign(value);
+}
+inline void CastMessage::set_payload_binary(const char* value) {
+  set_has_payload_binary();
+  if (payload_binary_ == &::google::protobuf::internal::kEmptyString) {
+    payload_binary_ = new ::std::string;
+  }
+  payload_binary_->assign(value);
+}
+inline void CastMessage::set_payload_binary(const void* value, size_t size) {
+  set_has_payload_binary();
+  if (payload_binary_ == &::google::protobuf::internal::kEmptyString) {
+    payload_binary_ = new ::std::string;
+  }
+  payload_binary_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* CastMessage::mutable_payload_binary() {
+  set_has_payload_binary();
+  if (payload_binary_ == &::google::protobuf::internal::kEmptyString) {
+    payload_binary_ = new ::std::string;
+  }
+  return payload_binary_;
+}
+inline ::std::string* CastMessage::release_payload_binary() {
+  clear_has_payload_binary();
+  if (payload_binary_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = payload_binary_;
+    payload_binary_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void CastMessage::set_allocated_payload_binary(::std::string* payload_binary) {
+  if (payload_binary_ != &::google::protobuf::internal::kEmptyString) {
+    delete payload_binary_;
+  }
+  if (payload_binary) {
+    set_has_payload_binary();
+    payload_binary_ = payload_binary;
+  } else {
+    clear_has_payload_binary();
+    payload_binary_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// AuthChallenge
+
+// -------------------------------------------------------------------
+
+// AuthResponse
+
+// required bytes signature = 1;
+inline bool AuthResponse::has_signature() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AuthResponse::set_has_signature() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AuthResponse::clear_has_signature() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AuthResponse::clear_signature() {
+  if (signature_ != &::google::protobuf::internal::kEmptyString) {
+    signature_->clear();
+  }
+  clear_has_signature();
+}
+inline const ::std::string& AuthResponse::signature() const {
+  return *signature_;
+}
+inline void AuthResponse::set_signature(const ::std::string& value) {
+  set_has_signature();
+  if (signature_ == &::google::protobuf::internal::kEmptyString) {
+    signature_ = new ::std::string;
+  }
+  signature_->assign(value);
+}
+inline void AuthResponse::set_signature(const char* value) {
+  set_has_signature();
+  if (signature_ == &::google::protobuf::internal::kEmptyString) {
+    signature_ = new ::std::string;
+  }
+  signature_->assign(value);
+}
+inline void AuthResponse::set_signature(const void* value, size_t size) {
+  set_has_signature();
+  if (signature_ == &::google::protobuf::internal::kEmptyString) {
+    signature_ = new ::std::string;
+  }
+  signature_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* AuthResponse::mutable_signature() {
+  set_has_signature();
+  if (signature_ == &::google::protobuf::internal::kEmptyString) {
+    signature_ = new ::std::string;
+  }
+  return signature_;
+}
+inline ::std::string* AuthResponse::release_signature() {
+  clear_has_signature();
+  if (signature_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = signature_;
+    signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void AuthResponse::set_allocated_signature(::std::string* signature) {
+  if (signature_ != &::google::protobuf::internal::kEmptyString) {
+    delete signature_;
+  }
+  if (signature) {
+    set_has_signature();
+    signature_ = signature;
+  } else {
+    clear_has_signature();
+    signature_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// required bytes client_auth_certificate = 2;
+inline bool AuthResponse::has_client_auth_certificate() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AuthResponse::set_has_client_auth_certificate() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AuthResponse::clear_has_client_auth_certificate() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AuthResponse::clear_client_auth_certificate() {
+  if (client_auth_certificate_ != &::google::protobuf::internal::kEmptyString) {
+    client_auth_certificate_->clear();
+  }
+  clear_has_client_auth_certificate();
+}
+inline const ::std::string& AuthResponse::client_auth_certificate() const {
+  return *client_auth_certificate_;
+}
+inline void AuthResponse::set_client_auth_certificate(const ::std::string& value) {
+  set_has_client_auth_certificate();
+  if (client_auth_certificate_ == &::google::protobuf::internal::kEmptyString) {
+    client_auth_certificate_ = new ::std::string;
+  }
+  client_auth_certificate_->assign(value);
+}
+inline void AuthResponse::set_client_auth_certificate(const char* value) {
+  set_has_client_auth_certificate();
+  if (client_auth_certificate_ == &::google::protobuf::internal::kEmptyString) {
+    client_auth_certificate_ = new ::std::string;
+  }
+  client_auth_certificate_->assign(value);
+}
+inline void AuthResponse::set_client_auth_certificate(const void* value, size_t size) {
+  set_has_client_auth_certificate();
+  if (client_auth_certificate_ == &::google::protobuf::internal::kEmptyString) {
+    client_auth_certificate_ = new ::std::string;
+  }
+  client_auth_certificate_->assign(reinterpret_cast<const char*>(value), size);
+}
+inline ::std::string* AuthResponse::mutable_client_auth_certificate() {
+  set_has_client_auth_certificate();
+  if (client_auth_certificate_ == &::google::protobuf::internal::kEmptyString) {
+    client_auth_certificate_ = new ::std::string;
+  }
+  return client_auth_certificate_;
+}
+inline ::std::string* AuthResponse::release_client_auth_certificate() {
+  clear_has_client_auth_certificate();
+  if (client_auth_certificate_ == &::google::protobuf::internal::kEmptyString) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_auth_certificate_;
+    client_auth_certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    return temp;
+  }
+}
+inline void AuthResponse::set_allocated_client_auth_certificate(::std::string* client_auth_certificate) {
+  if (client_auth_certificate_ != &::google::protobuf::internal::kEmptyString) {
+    delete client_auth_certificate_;
+  }
+  if (client_auth_certificate) {
+    set_has_client_auth_certificate();
+    client_auth_certificate_ = client_auth_certificate;
+  } else {
+    clear_has_client_auth_certificate();
+    client_auth_certificate_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+  }
+}
+
+// -------------------------------------------------------------------
+
+// AuthError
+
+// required .castchannel.AuthError.ErrorType error_type = 1;
+inline bool AuthError::has_error_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AuthError::set_has_error_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AuthError::clear_has_error_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AuthError::clear_error_type() {
+  error_type_ = 0;
+  clear_has_error_type();
+}
+inline ::castchannel::AuthError_ErrorType AuthError::error_type() const {
+  return static_cast< ::castchannel::AuthError_ErrorType >(error_type_);
+}
+inline void AuthError::set_error_type(::castchannel::AuthError_ErrorType value) {
+  assert(::castchannel::AuthError_ErrorType_IsValid(value));
+  set_has_error_type();
+  error_type_ = value;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceAuthMessage
+
+// optional .castchannel.AuthChallenge challenge = 1;
+inline bool DeviceAuthMessage::has_challenge() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DeviceAuthMessage::set_has_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DeviceAuthMessage::clear_has_challenge() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DeviceAuthMessage::clear_challenge() {
+  if (challenge_ != NULL) challenge_->::castchannel::AuthChallenge::Clear();
+  clear_has_challenge();
+}
+inline const ::castchannel::AuthChallenge& DeviceAuthMessage::challenge() const {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return challenge_ != NULL ? *challenge_ : *default_instance().challenge_;
+#else
+  return challenge_ != NULL ? *challenge_ : *default_instance_->challenge_;
+#endif
+}
+inline ::castchannel::AuthChallenge* DeviceAuthMessage::mutable_challenge() {
+  set_has_challenge();
+  if (challenge_ == NULL) challenge_ = new ::castchannel::AuthChallenge;
+  return challenge_;
+}
+inline ::castchannel::AuthChallenge* DeviceAuthMessage::release_challenge() {
+  clear_has_challenge();
+  ::castchannel::AuthChallenge* temp = challenge_;
+  challenge_ = NULL;
+  return temp;
+}
+inline void DeviceAuthMessage::set_allocated_challenge(::castchannel::AuthChallenge* challenge) {
+  delete challenge_;
+  challenge_ = challenge;
+  if (challenge) {
+    set_has_challenge();
+  } else {
+    clear_has_challenge();
+  }
+}
+
+// optional .castchannel.AuthResponse response = 2;
+inline bool DeviceAuthMessage::has_response() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DeviceAuthMessage::set_has_response() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DeviceAuthMessage::clear_has_response() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DeviceAuthMessage::clear_response() {
+  if (response_ != NULL) response_->::castchannel::AuthResponse::Clear();
+  clear_has_response();
+}
+inline const ::castchannel::AuthResponse& DeviceAuthMessage::response() const {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return response_ != NULL ? *response_ : *default_instance().response_;
+#else
+  return response_ != NULL ? *response_ : *default_instance_->response_;
+#endif
+}
+inline ::castchannel::AuthResponse* DeviceAuthMessage::mutable_response() {
+  set_has_response();
+  if (response_ == NULL) response_ = new ::castchannel::AuthResponse;
+  return response_;
+}
+inline ::castchannel::AuthResponse* DeviceAuthMessage::release_response() {
+  clear_has_response();
+  ::castchannel::AuthResponse* temp = response_;
+  response_ = NULL;
+  return temp;
+}
+inline void DeviceAuthMessage::set_allocated_response(::castchannel::AuthResponse* response) {
+  delete response_;
+  response_ = response;
+  if (response) {
+    set_has_response();
+  } else {
+    clear_has_response();
+  }
+}
+
+// optional .castchannel.AuthError error = 3;
+inline bool DeviceAuthMessage::has_error() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DeviceAuthMessage::set_has_error() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DeviceAuthMessage::clear_has_error() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DeviceAuthMessage::clear_error() {
+  if (error_ != NULL) error_->::castchannel::AuthError::Clear();
+  clear_has_error();
+}
+inline const ::castchannel::AuthError& DeviceAuthMessage::error() const {
+#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
+  return error_ != NULL ? *error_ : *default_instance().error_;
+#else
+  return error_ != NULL ? *error_ : *default_instance_->error_;
+#endif
+}
+inline ::castchannel::AuthError* DeviceAuthMessage::mutable_error() {
+  set_has_error();
+  if (error_ == NULL) error_ = new ::castchannel::AuthError;
+  return error_;
+}
+inline ::castchannel::AuthError* DeviceAuthMessage::release_error() {
+  clear_has_error();
+  ::castchannel::AuthError* temp = error_;
+  error_ = NULL;
+  return temp;
+}
+inline void DeviceAuthMessage::set_allocated_error(::castchannel::AuthError* error) {
+  delete error_;
+  error_ = error;
+  if (error) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace castchannel
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_cast_5fchannel_2eproto__INCLUDED
diff --git a/modules/stream_out/chromecast/cast_channel.proto b/modules/stream_out/chromecast/cast_channel.proto
new file mode 100644
index 0000000..96622c1
--- /dev/null
+++ b/modules/stream_out/chromecast/cast_channel.proto
@@ -0,0 +1,79 @@
+// Copyright 2013 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.
+
+syntax = "proto2";
+
+option optimize_for = LITE_RUNTIME;
+
+package castchannel;
+
+message CastMessage {
+  // Always pass a version of the protocol for future compatibility
+  // requirements.
+  enum ProtocolVersion {
+    CASTV2_1_0 = 0;
+  }
+  required ProtocolVersion protocol_version = 1;
+
+  // source and destination ids identify the origin and destination of the
+  // message.  They are used to route messages between endpoints that share a
+  // device-to-device channel.
+  //
+  // For messages between applications:
+  //   - The sender application id is a unique identifier generated on behalf of
+  //     the sender application.
+  //   - The receiver id is always the the session id for the application.
+  //
+  // For messages to or from the sender or receiver platform, the special ids
+  // 'sender-0' and 'receiver-0' can be used.
+  // 
+  // For messages intended for all endpoints using a given channel, the
+  // wildcard destination_id '*' can be used.
+  required string source_id = 2;
+  required string destination_id = 3;
+
+  // This is the core multiplexing key.  All messages are sent on a namespace
+  // and endpoints sharing a channel listen on one or more namespaces.  The
+  // namespace defines the protocol and semantics of the message.
+  required string namespace = 4;
+
+  // Encoding and payload info follows.
+
+  // What type of data do we have in this message.
+  enum PayloadType {
+    STRING = 0;
+    BINARY = 1;
+  }
+  required PayloadType payload_type = 5;
+
+  // Depending on payload_type, exactly one of the following optional fields
+  // will always be set.
+  optional string payload_utf8 = 6;
+  optional bytes payload_binary = 7;
+}
+
+// Messages for authentication protocol between a sender and a receiver.
+message AuthChallenge {
+}
+
+message AuthResponse {
+  required bytes signature = 1;
+  required bytes client_auth_certificate = 2;
+}
+
+message AuthError {
+  enum ErrorType {
+    INTERNAL_ERROR = 0;
+    NO_TLS = 1;  // The underlying connection is not TLS
+  }
+  required ErrorType error_type = 1;
+}
+
+message DeviceAuthMessage {
+  // Request fields
+  optional AuthChallenge challenge = 1;
+  // Response fields
+  optional AuthResponse response = 2;
+  optional AuthError error = 3;
+}
\ No newline at end of file
-- 
1.9.1