// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: rpc.proto

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "rpc.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace media {
namespace remoting {
namespace pb {
class DecoderBufferDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DecoderBuffer> {
} _DecoderBuffer_default_instance_;
class SizeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Size> {
} _Size_default_instance_;
class EncryptionSchemeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<EncryptionScheme> {
} _EncryptionScheme_default_instance_;
class AudioDecoderConfigDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<AudioDecoderConfig> {
} _AudioDecoderConfig_default_instance_;
class RectDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Rect> {
} _Rect_default_instance_;
class VideoDecoderConfigDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<VideoDecoderConfig> {
} _VideoDecoderConfig_default_instance_;
class DecryptConfig_SubSampleDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DecryptConfig_SubSample> {
} _DecryptConfig_SubSample_default_instance_;
class DecryptConfigDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DecryptConfig> {
} _DecryptConfig_default_instance_;
class PipelineStatisticsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<PipelineStatistics> {
} _PipelineStatistics_default_instance_;
class CdmKeyInformationDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmKeyInformation> {
} _CdmKeyInformation_default_instance_;
class RendererInitializeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererInitialize> {
} _RendererInitialize_default_instance_;
class RendererFlushUntilDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererFlushUntil> {
} _RendererFlushUntil_default_instance_;
class RendererSetCdmDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererSetCdm> {
} _RendererSetCdm_default_instance_;
class RendererClientOnTimeUpdateDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererClientOnTimeUpdate> {
} _RendererClientOnTimeUpdate_default_instance_;
class RendererClientOnBufferingStateChangeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererClientOnBufferingStateChange> {
} _RendererClientOnBufferingStateChange_default_instance_;
class RendererClientOnAudioConfigChangeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererClientOnAudioConfigChange> {
} _RendererClientOnAudioConfigChange_default_instance_;
class RendererClientOnVideoConfigChangeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RendererClientOnVideoConfigChange> {
} _RendererClientOnVideoConfigChange_default_instance_;
class DemuxerStreamReadUntilDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DemuxerStreamReadUntil> {
} _DemuxerStreamReadUntil_default_instance_;
class DemuxerStreamInitializeCallbackDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DemuxerStreamInitializeCallback> {
} _DemuxerStreamInitializeCallback_default_instance_;
class DemuxerStreamReadUntilCallbackDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<DemuxerStreamReadUntilCallback> {
} _DemuxerStreamReadUntilCallback_default_instance_;
class CdmInitializeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmInitialize> {
} _CdmInitialize_default_instance_;
class CdmSetServerCertificateDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmSetServerCertificate> {
} _CdmSetServerCertificate_default_instance_;
class CdmCreateSessionAndGenerateRequestDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmCreateSessionAndGenerateRequest> {
} _CdmCreateSessionAndGenerateRequest_default_instance_;
class CdmLoadSessionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmLoadSession> {
} _CdmLoadSession_default_instance_;
class CdmUpdateSessionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmUpdateSession> {
} _CdmUpdateSession_default_instance_;
class CdmCloseSessionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmCloseSession> {
} _CdmCloseSession_default_instance_;
class CdmRemoveSessionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmRemoveSession> {
} _CdmRemoveSession_default_instance_;
class CdmPromiseDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmPromise> {
} _CdmPromise_default_instance_;
class CdmClientOnSessionMessageDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmClientOnSessionMessage> {
} _CdmClientOnSessionMessage_default_instance_;
class CdmClientOnSessionKeysChangeDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmClientOnSessionKeysChange> {
} _CdmClientOnSessionKeysChange_default_instance_;
class CdmClientOnSessionExpirationUpdateDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CdmClientOnSessionExpirationUpdate> {
} _CdmClientOnSessionExpirationUpdate_default_instance_;
class RpcMessageDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<RpcMessage> {
  public:
  ::google::protobuf::int32 integer_value_;
  ::google::protobuf::int64 integer64_value_;
  double double_value_;
  bool boolean_value_;
  ::google::protobuf::internal::ArenaStringPtr string_value_;
  const ::media::remoting::pb::RendererInitialize* renderer_initialize_rpc_;
  const ::media::remoting::pb::RendererFlushUntil* renderer_flushuntil_rpc_;
  const ::media::remoting::pb::RendererSetCdm* renderer_set_cdm_rpc_;
  const ::media::remoting::pb::RendererClientOnTimeUpdate* rendererclient_ontimeupdate_rpc_;
  const ::media::remoting::pb::Size* rendererclient_onvideonatualsizechange_rpc_;
  const ::media::remoting::pb::PipelineStatistics* rendererclient_onstatisticsupdate_rpc_;
  const ::media::remoting::pb::RendererClientOnBufferingStateChange* rendererclient_onbufferingstatechange_rpc_;
  const ::media::remoting::pb::RendererClientOnAudioConfigChange* rendererclient_onaudioconfigchange_rpc_;
  const ::media::remoting::pb::RendererClientOnVideoConfigChange* rendererclient_onvideoconfigchange_rpc_;
  const ::media::remoting::pb::DemuxerStreamReadUntil* demuxerstream_readuntil_rpc_;
  const ::media::remoting::pb::DemuxerStreamInitializeCallback* demuxerstream_initializecb_rpc_;
  const ::media::remoting::pb::DemuxerStreamReadUntilCallback* demuxerstream_readuntilcb_rpc_;
  const ::media::remoting::pb::CdmInitialize* cdm_initialize_rpc_;
  const ::media::remoting::pb::CdmSetServerCertificate* cdm_setservercertificate_rpc_;
  const ::media::remoting::pb::CdmCreateSessionAndGenerateRequest* cdm_createsessionandgeneraterequest_rpc_;
  const ::media::remoting::pb::CdmLoadSession* cdm_loadsession_rpc_;
  const ::media::remoting::pb::CdmUpdateSession* cdm_updatesession_rpc_;
  const ::media::remoting::pb::CdmCloseSession* cdm_closesession_rpc_;
  const ::media::remoting::pb::CdmRemoveSession* cdm_removesession_rpc_;
  const ::media::remoting::pb::CdmPromise* cdm_promise_rpc_;
  const ::media::remoting::pb::CdmClientOnSessionMessage* cdmclient_onsessionmessage_rpc_;
  const ::media::remoting::pb::CdmClientOnSessionKeysChange* cdmclient_onsessionkeychange_rpc_;
  const ::media::remoting::pb::CdmClientOnSessionExpirationUpdate* cdmclient_onsessionexpirationupdate_rpc_;
} _RpcMessage_default_instance_;

namespace protobuf_rpc_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] = {
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
};


void TableStruct::Shutdown() {
  _DecoderBuffer_default_instance_.Shutdown();
  _Size_default_instance_.Shutdown();
  _EncryptionScheme_default_instance_.Shutdown();
  _AudioDecoderConfig_default_instance_.Shutdown();
  _Rect_default_instance_.Shutdown();
  _VideoDecoderConfig_default_instance_.Shutdown();
  _DecryptConfig_SubSample_default_instance_.Shutdown();
  _DecryptConfig_default_instance_.Shutdown();
  _PipelineStatistics_default_instance_.Shutdown();
  _CdmKeyInformation_default_instance_.Shutdown();
  _RendererInitialize_default_instance_.Shutdown();
  _RendererFlushUntil_default_instance_.Shutdown();
  _RendererSetCdm_default_instance_.Shutdown();
  _RendererClientOnTimeUpdate_default_instance_.Shutdown();
  _RendererClientOnBufferingStateChange_default_instance_.Shutdown();
  _RendererClientOnAudioConfigChange_default_instance_.Shutdown();
  _RendererClientOnVideoConfigChange_default_instance_.Shutdown();
  _DemuxerStreamReadUntil_default_instance_.Shutdown();
  _DemuxerStreamInitializeCallback_default_instance_.Shutdown();
  _DemuxerStreamReadUntilCallback_default_instance_.Shutdown();
  _CdmInitialize_default_instance_.Shutdown();
  _CdmSetServerCertificate_default_instance_.Shutdown();
  _CdmCreateSessionAndGenerateRequest_default_instance_.Shutdown();
  _CdmLoadSession_default_instance_.Shutdown();
  _CdmUpdateSession_default_instance_.Shutdown();
  _CdmCloseSession_default_instance_.Shutdown();
  _CdmRemoveSession_default_instance_.Shutdown();
  _CdmPromise_default_instance_.Shutdown();
  _CdmClientOnSessionMessage_default_instance_.Shutdown();
  _CdmClientOnSessionKeysChange_default_instance_.Shutdown();
  _CdmClientOnSessionExpirationUpdate_default_instance_.Shutdown();
  _RpcMessage_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _DecoderBuffer_default_instance_.DefaultConstruct();
  _Size_default_instance_.DefaultConstruct();
  _EncryptionScheme_default_instance_.DefaultConstruct();
  _AudioDecoderConfig_default_instance_.DefaultConstruct();
  _Rect_default_instance_.DefaultConstruct();
  _VideoDecoderConfig_default_instance_.DefaultConstruct();
  _DecryptConfig_SubSample_default_instance_.DefaultConstruct();
  _DecryptConfig_default_instance_.DefaultConstruct();
  _PipelineStatistics_default_instance_.DefaultConstruct();
  _CdmKeyInformation_default_instance_.DefaultConstruct();
  _RendererInitialize_default_instance_.DefaultConstruct();
  _RendererFlushUntil_default_instance_.DefaultConstruct();
  _RendererSetCdm_default_instance_.DefaultConstruct();
  _RendererClientOnTimeUpdate_default_instance_.DefaultConstruct();
  _RendererClientOnBufferingStateChange_default_instance_.DefaultConstruct();
  _RendererClientOnAudioConfigChange_default_instance_.DefaultConstruct();
  _RendererClientOnVideoConfigChange_default_instance_.DefaultConstruct();
  _DemuxerStreamReadUntil_default_instance_.DefaultConstruct();
  _DemuxerStreamInitializeCallback_default_instance_.DefaultConstruct();
  _DemuxerStreamReadUntilCallback_default_instance_.DefaultConstruct();
  _CdmInitialize_default_instance_.DefaultConstruct();
  _CdmSetServerCertificate_default_instance_.DefaultConstruct();
  _CdmCreateSessionAndGenerateRequest_default_instance_.DefaultConstruct();
  _CdmLoadSession_default_instance_.DefaultConstruct();
  _CdmUpdateSession_default_instance_.DefaultConstruct();
  _CdmCloseSession_default_instance_.DefaultConstruct();
  _CdmRemoveSession_default_instance_.DefaultConstruct();
  _CdmPromise_default_instance_.DefaultConstruct();
  _CdmClientOnSessionMessage_default_instance_.DefaultConstruct();
  _CdmClientOnSessionKeysChange_default_instance_.DefaultConstruct();
  _CdmClientOnSessionExpirationUpdate_default_instance_.DefaultConstruct();
  _RpcMessage_default_instance_.DefaultConstruct();
  _DecoderBuffer_default_instance_.get_mutable()->decrypt_config_ = const_cast< ::media::remoting::pb::DecryptConfig*>(
      ::media::remoting::pb::DecryptConfig::internal_default_instance());
  _AudioDecoderConfig_default_instance_.get_mutable()->encryption_scheme_ = const_cast< ::media::remoting::pb::EncryptionScheme*>(
      ::media::remoting::pb::EncryptionScheme::internal_default_instance());
  _VideoDecoderConfig_default_instance_.get_mutable()->encryption_scheme_ = const_cast< ::media::remoting::pb::EncryptionScheme*>(
      ::media::remoting::pb::EncryptionScheme::internal_default_instance());
  _VideoDecoderConfig_default_instance_.get_mutable()->coded_size_ = const_cast< ::media::remoting::pb::Size*>(
      ::media::remoting::pb::Size::internal_default_instance());
  _VideoDecoderConfig_default_instance_.get_mutable()->visible_rect_ = const_cast< ::media::remoting::pb::Rect*>(
      ::media::remoting::pb::Rect::internal_default_instance());
  _VideoDecoderConfig_default_instance_.get_mutable()->natural_size_ = const_cast< ::media::remoting::pb::Size*>(
      ::media::remoting::pb::Size::internal_default_instance());
  _RendererClientOnAudioConfigChange_default_instance_.get_mutable()->audio_decoder_config_ = const_cast< ::media::remoting::pb::AudioDecoderConfig*>(
      ::media::remoting::pb::AudioDecoderConfig::internal_default_instance());
  _RendererClientOnVideoConfigChange_default_instance_.get_mutable()->video_decoder_config_ = const_cast< ::media::remoting::pb::VideoDecoderConfig*>(
      ::media::remoting::pb::VideoDecoderConfig::internal_default_instance());
  _DemuxerStreamInitializeCallback_default_instance_.get_mutable()->audio_decoder_config_ = const_cast< ::media::remoting::pb::AudioDecoderConfig*>(
      ::media::remoting::pb::AudioDecoderConfig::internal_default_instance());
  _DemuxerStreamInitializeCallback_default_instance_.get_mutable()->video_decoder_config_ = const_cast< ::media::remoting::pb::VideoDecoderConfig*>(
      ::media::remoting::pb::VideoDecoderConfig::internal_default_instance());
  _DemuxerStreamReadUntilCallback_default_instance_.get_mutable()->audio_decoder_config_ = const_cast< ::media::remoting::pb::AudioDecoderConfig*>(
      ::media::remoting::pb::AudioDecoderConfig::internal_default_instance());
  _DemuxerStreamReadUntilCallback_default_instance_.get_mutable()->video_decoder_config_ = const_cast< ::media::remoting::pb::VideoDecoderConfig*>(
      ::media::remoting::pb::VideoDecoderConfig::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void AddDescriptorsImpl() {
  InitDefaults();
  ::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_rpc_2eproto

bool EncryptionScheme_CipherMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const EncryptionScheme_CipherMode EncryptionScheme::CIPHER_MODE_UNENCRYPTED;
const EncryptionScheme_CipherMode EncryptionScheme::CIPHER_MODE_AES_CTR;
const EncryptionScheme_CipherMode EncryptionScheme::CIPHER_MODE_AES_CBC;
const EncryptionScheme_CipherMode EncryptionScheme::CipherMode_MIN;
const EncryptionScheme_CipherMode EncryptionScheme::CipherMode_MAX;
const int EncryptionScheme::CipherMode_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool AudioDecoderConfig_Codec_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const AudioDecoderConfig_Codec AudioDecoderConfig::kUnknownAudioCodec;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAAC;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecMP3;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecVorbis;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecFLAC;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAMR_NB;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAMR_WB;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_MULAW;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecGSM_MS;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_S16BE;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_S24BE;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecOpus;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecEAC3;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_ALAW;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecALAC;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAC3;
const AudioDecoderConfig_Codec AudioDecoderConfig::kCodecMpegHAudio;
const AudioDecoderConfig_Codec AudioDecoderConfig::Codec_MIN;
const AudioDecoderConfig_Codec AudioDecoderConfig::Codec_MAX;
const int AudioDecoderConfig::Codec_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool AudioDecoderConfig_SampleFormat_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kUnknownSampleFormat;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatU8;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatS16;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatS32;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatF32;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarS16;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarF32;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarS32;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatS24;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatAc3;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatEac3;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatMpegHAudio;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::SampleFormat_MIN;
const AudioDecoderConfig_SampleFormat AudioDecoderConfig::SampleFormat_MAX;
const int AudioDecoderConfig::SampleFormat_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool AudioDecoderConfig_ChannelLayout_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_NONE;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_UNSUPPORTED;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_MONO;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_STEREO;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_2_1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_SURROUND;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_4_0;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_2_2;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_QUAD;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_0;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_0_BACK;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_1_BACK;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_0;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_1_WIDE;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_STEREO_DOWNMIX;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_2POINT1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_3_1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_4_1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_0;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_0_FRONT;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_HEXAGONAL;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_1;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_1_BACK;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_1_FRONT;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_0_FRONT;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_1_WIDE_BACK;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_OCTAGONAL;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_DISCRETE;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_4_1_QUAD_SIDE;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_BITSTREAM;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::ChannelLayout_MIN;
const AudioDecoderConfig_ChannelLayout AudioDecoderConfig::ChannelLayout_MAX;
const int AudioDecoderConfig::ChannelLayout_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool VideoDecoderConfig_Codec_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const VideoDecoderConfig_Codec VideoDecoderConfig::kUnknownVideoCodec;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecH264;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecVC1;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecMPEG2;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecMPEG4;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecTheora;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecVP8;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecVP9;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecHEVC;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecDolbyVision;
const VideoDecoderConfig_Codec VideoDecoderConfig::kCodecAV1;
const VideoDecoderConfig_Codec VideoDecoderConfig::Codec_MIN;
const VideoDecoderConfig_Codec VideoDecoderConfig::Codec_MAX;
const int VideoDecoderConfig::Codec_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool VideoDecoderConfig_Profile_IsValid(int value) {
  switch (value) {
    case -1:
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const VideoDecoderConfig_Profile VideoDecoderConfig::VIDEO_CODEC_PROFILE_UNKNOWN;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_BASELINE;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_MAIN;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_EXTENDED;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH10PROFILE;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH422PROFILE;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH444PREDICTIVEPROFILE;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_SCALABLEBASELINE;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_SCALABLEHIGH;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_STEREOHIGH;
const VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_MULTIVIEWHIGH;
const VideoDecoderConfig_Profile VideoDecoderConfig::VP8PROFILE_ANY;
const VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE0;
const VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE1;
const VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE2;
const VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE3;
const VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MAIN;
const VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MAIN10;
const VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MAIN_STILL_PICTURE;
const VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE0;
const VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE4;
const VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE5;
const VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE7;
const VideoDecoderConfig_Profile VideoDecoderConfig::THEORAPROFILE_ANY;
const VideoDecoderConfig_Profile VideoDecoderConfig::AV1PROFILE_PROFILE_MAIN;
const VideoDecoderConfig_Profile VideoDecoderConfig::AV1PROFILE_PROFILE_HIGH;
const VideoDecoderConfig_Profile VideoDecoderConfig::AV1PROFILE_PROFILE_PRO;
const VideoDecoderConfig_Profile VideoDecoderConfig::Profile_MIN;
const VideoDecoderConfig_Profile VideoDecoderConfig::Profile_MAX;
const int VideoDecoderConfig::Profile_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool VideoDecoderConfig_Format_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_UNKNOWN;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I420;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YV12;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I422;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I420A;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I444;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV12;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV21;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_UYVY;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUY2;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_ARGB;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_XRGB;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_RGB24;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_RGB32;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_MJPEG;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_MT21;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420P9;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420P10;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422P9;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422P10;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444P9;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444P10;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420P12;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422P12;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444P12;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_Y8;
const VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_Y16;
const VideoDecoderConfig_Format VideoDecoderConfig::Format_MIN;
const VideoDecoderConfig_Format VideoDecoderConfig::Format_MAX;
const int VideoDecoderConfig::Format_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool VideoDecoderConfig_ColorSpace_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_UNSPECIFIED;
const VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_JPEG;
const VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_HD_REC709;
const VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_SD_REC601;
const VideoDecoderConfig_ColorSpace VideoDecoderConfig::ColorSpace_MIN;
const VideoDecoderConfig_ColorSpace VideoDecoderConfig::ColorSpace_MAX;
const int VideoDecoderConfig::ColorSpace_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool CdmKeyInformation_KeyStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const CdmKeyInformation_KeyStatus CdmKeyInformation::USABLE;
const CdmKeyInformation_KeyStatus CdmKeyInformation::INTERNAL_ERROR;
const CdmKeyInformation_KeyStatus CdmKeyInformation::EXPIRED;
const CdmKeyInformation_KeyStatus CdmKeyInformation::OUTPUT_RESTRICTED;
const CdmKeyInformation_KeyStatus CdmKeyInformation::OUTPUT_DOWNSCALED;
const CdmKeyInformation_KeyStatus CdmKeyInformation::KEY_STATUS_PENDING;
const CdmKeyInformation_KeyStatus CdmKeyInformation::RELEASED;
const CdmKeyInformation_KeyStatus CdmKeyInformation::KeyStatus_MIN;
const CdmKeyInformation_KeyStatus CdmKeyInformation::KeyStatus_MAX;
const int CdmKeyInformation::KeyStatus_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool RendererClientOnBufferingStateChange_State_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::BUFFERING_HAVE_NOTHING;
const RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::BUFFERING_HAVE_ENOUGH;
const RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::State_MIN;
const RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::State_MAX;
const int RendererClientOnBufferingStateChange::State_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool DemuxerStreamReadUntilCallback_Status_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kOk;
const DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kAborted;
const DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kConfigChanged;
const DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kError;
const DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::Status_MIN;
const DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::Status_MAX;
const int DemuxerStreamReadUntilCallback::Status_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool CdmCreateSessionAndGenerateRequest_EmeInitDataType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::UNKNOWN;
const CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::WEBM;
const CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::CENC;
const CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::KEYIDS;
const CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::EmeInitDataType_MIN;
const CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::EmeInitDataType_MAX;
const int CdmCreateSessionAndGenerateRequest::EmeInitDataType_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool RpcMessage_RpcProc_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 1000:
    case 1001:
    case 1002:
    case 1003:
    case 1004:
    case 1005:
    case 1100:
    case 1101:
    case 1102:
    case 2000:
    case 2001:
    case 2002:
    case 2003:
    case 2004:
    case 2005:
    case 2006:
    case 2007:
    case 2008:
    case 2009:
    case 2010:
    case 3000:
    case 3001:
    case 3002:
    case 3100:
    case 3101:
    case 4000:
    case 4001:
    case 4002:
    case 4003:
    case 4004:
    case 4005:
    case 4006:
    case 4007:
    case 4100:
    case 4101:
    case 4102:
    case 4103:
    case 4104:
    case 4105:
    case 4106:
    case 5000:
    case 5001:
    case 5002:
    case 5003:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const RpcMessage_RpcProc RpcMessage::RPC_INTERNAL;
const RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_RENDERER;
const RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_RENDERER_DONE;
const RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_CDM;
const RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_CDM_DONE;
const RpcMessage_RpcProc RpcMessage::RPC_R_INITIALIZE;
const RpcMessage_RpcProc RpcMessage::RPC_R_FLUSHUNTIL;
const RpcMessage_RpcProc RpcMessage::RPC_R_STARTPLAYINGFROM;
const RpcMessage_RpcProc RpcMessage::RPC_R_SETPLAYBACKRATE;
const RpcMessage_RpcProc RpcMessage::RPC_R_SETVOLUME;
const RpcMessage_RpcProc RpcMessage::RPC_R_SETCDM;
const RpcMessage_RpcProc RpcMessage::RPC_R_INITIALIZE_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_R_FLUSHUNTIL_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_R_SETCDM_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONTIMEUPDATE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONBUFFERINGSTATECHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONENDED;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONERROR;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONVIDEONATURALSIZECHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONVIDEOOPACITYCHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONSTATISTICSUPDATE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONWAITINGFORDECRYPTIONKEY;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONDURATIONCHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONAUDIOCONFIGCHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_RC_ONVIDEOCONFIGCHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_DS_INITIALIZE;
const RpcMessage_RpcProc RpcMessage::RPC_DS_READUNTIL;
const RpcMessage_RpcProc RpcMessage::RPC_DS_ENABLEBITSTREAMCONVERTER;
const RpcMessage_RpcProc RpcMessage::RPC_DS_INITIALIZE_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_DS_READUNTIL_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_SETCLIENT;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_INITIALIZE;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_SETSERVERCERTIFICATE;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_CREATESESSIONANDGENERATEREQUEST;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_LOADSESSION;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_UPDATESESSION;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_CLOSESESSION;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_REMOVESESSION;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_INITIALIZE_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_SETSERVERCERTIFICATE_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_CREATESESSIONANDGENERATEREQUEST_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_LOADSESSION_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_UPDATESESSION_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_CLOSESESSION_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDM_REMOVESESSION_CALLBACK;
const RpcMessage_RpcProc RpcMessage::RPC_CDMC_ONSESSIONMESSAGE;
const RpcMessage_RpcProc RpcMessage::RPC_CDMC_ONSESSIONCLOSED;
const RpcMessage_RpcProc RpcMessage::RPC_CDMC_ONSESSIONKEYSCHANGE;
const RpcMessage_RpcProc RpcMessage::RPC_CDMC_ONSESSIONEXPIRATIONUPDATE;
const RpcMessage_RpcProc RpcMessage::RpcProc_MIN;
const RpcMessage_RpcProc RpcMessage::RpcProc_MAX;
const int RpcMessage::RpcProc_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
bool EncryptionMode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

bool CdmException_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}

bool CdmMessageType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

bool CdmSessionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DecoderBuffer::kTimestampUsecFieldNumber;
const int DecoderBuffer::kDurationUsecFieldNumber;
const int DecoderBuffer::kIsKeyFrameFieldNumber;
const int DecoderBuffer::kDecryptConfigFieldNumber;
const int DecoderBuffer::kFrontDiscardUsecFieldNumber;
const int DecoderBuffer::kBackDiscardUsecFieldNumber;
const int DecoderBuffer::kSpliceTimestampUsecFieldNumber;
const int DecoderBuffer::kSideDataFieldNumber;
const int DecoderBuffer::kIsEosFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DecoderBuffer::DecoderBuffer()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.DecoderBuffer)
}
DecoderBuffer::DecoderBuffer(const DecoderBuffer& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  side_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_side_data()) {
    side_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.side_data_);
  }
  if (from.has_decrypt_config()) {
    decrypt_config_ = new ::media::remoting::pb::DecryptConfig(*from.decrypt_config_);
  } else {
    decrypt_config_ = NULL;
  }
  ::memcpy(&timestamp_usec_, &from.timestamp_usec_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_eos_) -
    reinterpret_cast<char*>(&timestamp_usec_)) + sizeof(is_eos_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.DecoderBuffer)
}

void DecoderBuffer::SharedCtor() {
  _cached_size_ = 0;
  side_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&decrypt_config_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&is_eos_) -
      reinterpret_cast<char*>(&decrypt_config_)) + sizeof(is_eos_));
}

DecoderBuffer::~DecoderBuffer() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.DecoderBuffer)
  SharedDtor();
}

void DecoderBuffer::SharedDtor() {
  side_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete decrypt_config_;
  }
}

void DecoderBuffer::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DecoderBuffer& DecoderBuffer::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

DecoderBuffer* DecoderBuffer::New(::google::protobuf::Arena* arena) const {
  DecoderBuffer* n = new DecoderBuffer;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DecoderBuffer::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.DecoderBuffer)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_side_data()) {
      GOOGLE_DCHECK(!side_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*side_data_.UnsafeRawStringPointer())->clear();
    }
    if (has_decrypt_config()) {
      GOOGLE_DCHECK(decrypt_config_ != NULL);
      decrypt_config_->::media::remoting::pb::DecryptConfig::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 252u) {
    ::memset(&timestamp_usec_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&is_key_frame_) -
        reinterpret_cast<char*>(&timestamp_usec_)) + sizeof(is_key_frame_));
  }
  is_eos_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DecoderBuffer::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.DecoderBuffer)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 timestamp_usec = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_timestamp_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &timestamp_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 duration_usec = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_duration_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &duration_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_key_frame = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_is_key_frame();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_key_frame_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.DecryptConfig decrypt_config = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_decrypt_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 front_discard_usec = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_front_discard_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &front_discard_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 back_discard_usec = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_back_discard_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &back_discard_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 splice_timestamp_usec = 7 [deprecated = true];
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u)) {
          set_has_splice_timestamp_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &splice_timestamp_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes side_data = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_side_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_eos = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u)) {
          set_has_is_eos();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_eos_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.DecoderBuffer)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.DecoderBuffer)
  return false;
#undef DO_
}

void DecoderBuffer::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.DecoderBuffer)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int64 timestamp_usec = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->timestamp_usec(), output);
  }

  // optional int64 duration_usec = 2;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->duration_usec(), output);
  }

  // optional bool is_key_frame = 3;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_key_frame(), output);
  }

  // optional .media.remoting.pb.DecryptConfig decrypt_config = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->decrypt_config_, output);
  }

  // optional int64 front_discard_usec = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->front_discard_usec(), output);
  }

  // optional int64 back_discard_usec = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->back_discard_usec(), output);
  }

  // optional int64 splice_timestamp_usec = 7 [deprecated = true];
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->splice_timestamp_usec(), output);
  }

  // optional bytes side_data = 8;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      8, this->side_data(), output);
  }

  // optional bool is_eos = 9;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_eos(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.DecoderBuffer)
}

size_t DecoderBuffer::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.DecoderBuffer)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional bytes side_data = 8;
    if (has_side_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->side_data());
    }

    // optional .media.remoting.pb.DecryptConfig decrypt_config = 4;
    if (has_decrypt_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->decrypt_config_);
    }

    // optional int64 timestamp_usec = 1;
    if (has_timestamp_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->timestamp_usec());
    }

    // optional int64 duration_usec = 2;
    if (has_duration_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->duration_usec());
    }

    // optional int64 front_discard_usec = 5;
    if (has_front_discard_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->front_discard_usec());
    }

    // optional int64 back_discard_usec = 6;
    if (has_back_discard_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->back_discard_usec());
    }

    // optional int64 splice_timestamp_usec = 7 [deprecated = true];
    if (has_splice_timestamp_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->splice_timestamp_usec());
    }

    // optional bool is_key_frame = 3;
    if (has_is_key_frame()) {
      total_size += 1 + 1;
    }

  }
  // optional bool is_eos = 9;
  if (has_is_eos()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DecoderBuffer::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DecoderBuffer*>(&from));
}

void DecoderBuffer::MergeFrom(const DecoderBuffer& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.DecoderBuffer)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_side_data();
      side_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.side_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_decrypt_config()->::media::remoting::pb::DecryptConfig::MergeFrom(from.decrypt_config());
    }
    if (cached_has_bits & 0x00000004u) {
      timestamp_usec_ = from.timestamp_usec_;
    }
    if (cached_has_bits & 0x00000008u) {
      duration_usec_ = from.duration_usec_;
    }
    if (cached_has_bits & 0x00000010u) {
      front_discard_usec_ = from.front_discard_usec_;
    }
    if (cached_has_bits & 0x00000020u) {
      back_discard_usec_ = from.back_discard_usec_;
    }
    if (cached_has_bits & 0x00000040u) {
      splice_timestamp_usec_ = from.splice_timestamp_usec_;
    }
    if (cached_has_bits & 0x00000080u) {
      is_key_frame_ = from.is_key_frame_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    set_is_eos(from.is_eos());
  }
}

void DecoderBuffer::CopyFrom(const DecoderBuffer& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.DecoderBuffer)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DecoderBuffer::IsInitialized() const {
  return true;
}

void DecoderBuffer::Swap(DecoderBuffer* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DecoderBuffer::InternalSwap(DecoderBuffer* other) {
  side_data_.Swap(&other->side_data_);
  std::swap(decrypt_config_, other->decrypt_config_);
  std::swap(timestamp_usec_, other->timestamp_usec_);
  std::swap(duration_usec_, other->duration_usec_);
  std::swap(front_discard_usec_, other->front_discard_usec_);
  std::swap(back_discard_usec_, other->back_discard_usec_);
  std::swap(splice_timestamp_usec_, other->splice_timestamp_usec_);
  std::swap(is_key_frame_, other->is_key_frame_);
  std::swap(is_eos_, other->is_eos_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DecoderBuffer::GetTypeName() const {
  return "media.remoting.pb.DecoderBuffer";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DecoderBuffer

// optional int64 timestamp_usec = 1;
bool DecoderBuffer::has_timestamp_usec() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void DecoderBuffer::set_has_timestamp_usec() {
  _has_bits_[0] |= 0x00000004u;
}
void DecoderBuffer::clear_has_timestamp_usec() {
  _has_bits_[0] &= ~0x00000004u;
}
void DecoderBuffer::clear_timestamp_usec() {
  timestamp_usec_ = GOOGLE_LONGLONG(0);
  clear_has_timestamp_usec();
}
::google::protobuf::int64 DecoderBuffer::timestamp_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.timestamp_usec)
  return timestamp_usec_;
}
void DecoderBuffer::set_timestamp_usec(::google::protobuf::int64 value) {
  set_has_timestamp_usec();
  timestamp_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.timestamp_usec)
}

// optional int64 duration_usec = 2;
bool DecoderBuffer::has_duration_usec() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void DecoderBuffer::set_has_duration_usec() {
  _has_bits_[0] |= 0x00000008u;
}
void DecoderBuffer::clear_has_duration_usec() {
  _has_bits_[0] &= ~0x00000008u;
}
void DecoderBuffer::clear_duration_usec() {
  duration_usec_ = GOOGLE_LONGLONG(0);
  clear_has_duration_usec();
}
::google::protobuf::int64 DecoderBuffer::duration_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.duration_usec)
  return duration_usec_;
}
void DecoderBuffer::set_duration_usec(::google::protobuf::int64 value) {
  set_has_duration_usec();
  duration_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.duration_usec)
}

// optional bool is_key_frame = 3;
bool DecoderBuffer::has_is_key_frame() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void DecoderBuffer::set_has_is_key_frame() {
  _has_bits_[0] |= 0x00000080u;
}
void DecoderBuffer::clear_has_is_key_frame() {
  _has_bits_[0] &= ~0x00000080u;
}
void DecoderBuffer::clear_is_key_frame() {
  is_key_frame_ = false;
  clear_has_is_key_frame();
}
bool DecoderBuffer::is_key_frame() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.is_key_frame)
  return is_key_frame_;
}
void DecoderBuffer::set_is_key_frame(bool value) {
  set_has_is_key_frame();
  is_key_frame_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.is_key_frame)
}

// optional .media.remoting.pb.DecryptConfig decrypt_config = 4;
bool DecoderBuffer::has_decrypt_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DecoderBuffer::set_has_decrypt_config() {
  _has_bits_[0] |= 0x00000002u;
}
void DecoderBuffer::clear_has_decrypt_config() {
  _has_bits_[0] &= ~0x00000002u;
}
void DecoderBuffer::clear_decrypt_config() {
  if (decrypt_config_ != NULL) decrypt_config_->::media::remoting::pb::DecryptConfig::Clear();
  clear_has_decrypt_config();
}
const ::media::remoting::pb::DecryptConfig& DecoderBuffer::decrypt_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.decrypt_config)
  return decrypt_config_ != NULL ? *decrypt_config_
                         : *::media::remoting::pb::DecryptConfig::internal_default_instance();
}
::media::remoting::pb::DecryptConfig* DecoderBuffer::mutable_decrypt_config() {
  set_has_decrypt_config();
  if (decrypt_config_ == NULL) {
    decrypt_config_ = new ::media::remoting::pb::DecryptConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DecoderBuffer.decrypt_config)
  return decrypt_config_;
}
::media::remoting::pb::DecryptConfig* DecoderBuffer::release_decrypt_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DecoderBuffer.decrypt_config)
  clear_has_decrypt_config();
  ::media::remoting::pb::DecryptConfig* temp = decrypt_config_;
  decrypt_config_ = NULL;
  return temp;
}
void DecoderBuffer::set_allocated_decrypt_config(::media::remoting::pb::DecryptConfig* decrypt_config) {
  delete decrypt_config_;
  decrypt_config_ = decrypt_config;
  if (decrypt_config) {
    set_has_decrypt_config();
  } else {
    clear_has_decrypt_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DecoderBuffer.decrypt_config)
}

// optional int64 front_discard_usec = 5;
bool DecoderBuffer::has_front_discard_usec() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void DecoderBuffer::set_has_front_discard_usec() {
  _has_bits_[0] |= 0x00000010u;
}
void DecoderBuffer::clear_has_front_discard_usec() {
  _has_bits_[0] &= ~0x00000010u;
}
void DecoderBuffer::clear_front_discard_usec() {
  front_discard_usec_ = GOOGLE_LONGLONG(0);
  clear_has_front_discard_usec();
}
::google::protobuf::int64 DecoderBuffer::front_discard_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.front_discard_usec)
  return front_discard_usec_;
}
void DecoderBuffer::set_front_discard_usec(::google::protobuf::int64 value) {
  set_has_front_discard_usec();
  front_discard_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.front_discard_usec)
}

// optional int64 back_discard_usec = 6;
bool DecoderBuffer::has_back_discard_usec() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void DecoderBuffer::set_has_back_discard_usec() {
  _has_bits_[0] |= 0x00000020u;
}
void DecoderBuffer::clear_has_back_discard_usec() {
  _has_bits_[0] &= ~0x00000020u;
}
void DecoderBuffer::clear_back_discard_usec() {
  back_discard_usec_ = GOOGLE_LONGLONG(0);
  clear_has_back_discard_usec();
}
::google::protobuf::int64 DecoderBuffer::back_discard_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.back_discard_usec)
  return back_discard_usec_;
}
void DecoderBuffer::set_back_discard_usec(::google::protobuf::int64 value) {
  set_has_back_discard_usec();
  back_discard_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.back_discard_usec)
}

// optional int64 splice_timestamp_usec = 7 [deprecated = true];
bool DecoderBuffer::has_splice_timestamp_usec() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void DecoderBuffer::set_has_splice_timestamp_usec() {
  _has_bits_[0] |= 0x00000040u;
}
void DecoderBuffer::clear_has_splice_timestamp_usec() {
  _has_bits_[0] &= ~0x00000040u;
}
void DecoderBuffer::clear_splice_timestamp_usec() {
  splice_timestamp_usec_ = GOOGLE_LONGLONG(0);
  clear_has_splice_timestamp_usec();
}
::google::protobuf::int64 DecoderBuffer::splice_timestamp_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.splice_timestamp_usec)
  return splice_timestamp_usec_;
}
void DecoderBuffer::set_splice_timestamp_usec(::google::protobuf::int64 value) {
  set_has_splice_timestamp_usec();
  splice_timestamp_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.splice_timestamp_usec)
}

// optional bytes side_data = 8;
bool DecoderBuffer::has_side_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DecoderBuffer::set_has_side_data() {
  _has_bits_[0] |= 0x00000001u;
}
void DecoderBuffer::clear_has_side_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void DecoderBuffer::clear_side_data() {
  side_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_side_data();
}
const ::std::string& DecoderBuffer::side_data() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.side_data)
  return side_data_.GetNoArena();
}
void DecoderBuffer::set_side_data(const ::std::string& value) {
  set_has_side_data();
  side_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.side_data)
}
#if LANG_CXX11
void DecoderBuffer::set_side_data(::std::string&& value) {
  set_has_side_data();
  side_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.DecoderBuffer.side_data)
}
#endif
void DecoderBuffer::set_side_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_side_data();
  side_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.DecoderBuffer.side_data)
}
void DecoderBuffer::set_side_data(const void* value, size_t size) {
  set_has_side_data();
  side_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.DecoderBuffer.side_data)
}
::std::string* DecoderBuffer::mutable_side_data() {
  set_has_side_data();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DecoderBuffer.side_data)
  return side_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DecoderBuffer::release_side_data() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DecoderBuffer.side_data)
  clear_has_side_data();
  return side_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DecoderBuffer::set_allocated_side_data(::std::string* side_data) {
  if (side_data != NULL) {
    set_has_side_data();
  } else {
    clear_has_side_data();
  }
  side_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), side_data);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DecoderBuffer.side_data)
}

// optional bool is_eos = 9;
bool DecoderBuffer::has_is_eos() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void DecoderBuffer::set_has_is_eos() {
  _has_bits_[0] |= 0x00000100u;
}
void DecoderBuffer::clear_has_is_eos() {
  _has_bits_[0] &= ~0x00000100u;
}
void DecoderBuffer::clear_is_eos() {
  is_eos_ = false;
  clear_has_is_eos();
}
bool DecoderBuffer::is_eos() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecoderBuffer.is_eos)
  return is_eos_;
}
void DecoderBuffer::set_is_eos(bool value) {
  set_has_is_eos();
  is_eos_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecoderBuffer.is_eos)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Size::kWidthFieldNumber;
const int Size::kHeightFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Size::Size()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.Size)
}
Size::Size(const Size& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&width_, &from.width_,
    static_cast<size_t>(reinterpret_cast<char*>(&height_) -
    reinterpret_cast<char*>(&width_)) + sizeof(height_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.Size)
}

void Size::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&width_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&height_) -
      reinterpret_cast<char*>(&width_)) + sizeof(height_));
}

Size::~Size() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.Size)
  SharedDtor();
}

void Size::SharedDtor() {
}

void Size::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Size& Size::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

Size* Size::New(::google::protobuf::Arena* arena) const {
  Size* n = new Size;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Size::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.Size)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&width_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&height_) -
        reinterpret_cast<char*>(&width_)) + sizeof(height_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Size::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.Size)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 width = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 height = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.Size)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.Size)
  return false;
#undef DO_
}

void Size::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.Size)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 width = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->width(), output);
  }

  // optional int32 height = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->height(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.Size)
}

size_t Size::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.Size)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 width = 1;
    if (has_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->width());
    }

    // optional int32 height = 2;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Size::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Size*>(&from));
}

void Size::MergeFrom(const Size& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.Size)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000002u) {
      height_ = from.height_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Size::CopyFrom(const Size& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.Size)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Size::IsInitialized() const {
  return true;
}

void Size::Swap(Size* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Size::InternalSwap(Size* other) {
  std::swap(width_, other->width_);
  std::swap(height_, other->height_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Size::GetTypeName() const {
  return "media.remoting.pb.Size";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Size

// optional int32 width = 1;
bool Size::has_width() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Size::set_has_width() {
  _has_bits_[0] |= 0x00000001u;
}
void Size::clear_has_width() {
  _has_bits_[0] &= ~0x00000001u;
}
void Size::clear_width() {
  width_ = 0;
  clear_has_width();
}
::google::protobuf::int32 Size::width() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.Size.width)
  return width_;
}
void Size::set_width(::google::protobuf::int32 value) {
  set_has_width();
  width_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.Size.width)
}

// optional int32 height = 2;
bool Size::has_height() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Size::set_has_height() {
  _has_bits_[0] |= 0x00000002u;
}
void Size::clear_has_height() {
  _has_bits_[0] &= ~0x00000002u;
}
void Size::clear_height() {
  height_ = 0;
  clear_has_height();
}
::google::protobuf::int32 Size::height() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.Size.height)
  return height_;
}
void Size::set_height(::google::protobuf::int32 value) {
  set_has_height();
  height_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.Size.height)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int EncryptionScheme::kModeFieldNumber;
const int EncryptionScheme::kEncryptBlocksFieldNumber;
const int EncryptionScheme::kSkipBlocksFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

EncryptionScheme::EncryptionScheme()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.EncryptionScheme)
}
EncryptionScheme::EncryptionScheme(const EncryptionScheme& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&mode_, &from.mode_,
    static_cast<size_t>(reinterpret_cast<char*>(&skip_blocks_) -
    reinterpret_cast<char*>(&mode_)) + sizeof(skip_blocks_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.EncryptionScheme)
}

void EncryptionScheme::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&mode_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&skip_blocks_) -
      reinterpret_cast<char*>(&mode_)) + sizeof(skip_blocks_));
}

EncryptionScheme::~EncryptionScheme() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.EncryptionScheme)
  SharedDtor();
}

void EncryptionScheme::SharedDtor() {
}

void EncryptionScheme::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EncryptionScheme& EncryptionScheme::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

EncryptionScheme* EncryptionScheme::New(::google::protobuf::Arena* arena) const {
  EncryptionScheme* n = new EncryptionScheme;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void EncryptionScheme::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.EncryptionScheme)
  if (_has_bits_[0 / 32] & 7u) {
    ::memset(&mode_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&skip_blocks_) -
        reinterpret_cast<char*>(&mode_)) + sizeof(skip_blocks_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool EncryptionScheme::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.EncryptionScheme)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.EncryptionScheme.CipherMode mode = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::EncryptionScheme_CipherMode_IsValid(value)) {
            set_mode(static_cast< ::media::remoting::pb::EncryptionScheme_CipherMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 encrypt_blocks = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_encrypt_blocks();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &encrypt_blocks_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 skip_blocks = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_skip_blocks();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &skip_blocks_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.EncryptionScheme)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.EncryptionScheme)
  return false;
#undef DO_
}

void EncryptionScheme::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.EncryptionScheme)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.EncryptionScheme.CipherMode mode = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->mode(), output);
  }

  // optional uint32 encrypt_blocks = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->encrypt_blocks(), output);
  }

  // optional uint32 skip_blocks = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->skip_blocks(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.EncryptionScheme)
}

size_t EncryptionScheme::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.EncryptionScheme)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional .media.remoting.pb.EncryptionScheme.CipherMode mode = 1;
    if (has_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->mode());
    }

    // optional uint32 encrypt_blocks = 2;
    if (has_encrypt_blocks()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->encrypt_blocks());
    }

    // optional uint32 skip_blocks = 3;
    if (has_skip_blocks()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->skip_blocks());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EncryptionScheme::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EncryptionScheme*>(&from));
}

void EncryptionScheme::MergeFrom(const EncryptionScheme& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.EncryptionScheme)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mode_ = from.mode_;
    }
    if (cached_has_bits & 0x00000002u) {
      encrypt_blocks_ = from.encrypt_blocks_;
    }
    if (cached_has_bits & 0x00000004u) {
      skip_blocks_ = from.skip_blocks_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void EncryptionScheme::CopyFrom(const EncryptionScheme& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.EncryptionScheme)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EncryptionScheme::IsInitialized() const {
  return true;
}

void EncryptionScheme::Swap(EncryptionScheme* other) {
  if (other == this) return;
  InternalSwap(other);
}
void EncryptionScheme::InternalSwap(EncryptionScheme* other) {
  std::swap(mode_, other->mode_);
  std::swap(encrypt_blocks_, other->encrypt_blocks_);
  std::swap(skip_blocks_, other->skip_blocks_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string EncryptionScheme::GetTypeName() const {
  return "media.remoting.pb.EncryptionScheme";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// EncryptionScheme

// optional .media.remoting.pb.EncryptionScheme.CipherMode mode = 1;
bool EncryptionScheme::has_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void EncryptionScheme::set_has_mode() {
  _has_bits_[0] |= 0x00000001u;
}
void EncryptionScheme::clear_has_mode() {
  _has_bits_[0] &= ~0x00000001u;
}
void EncryptionScheme::clear_mode() {
  mode_ = 0;
  clear_has_mode();
}
::media::remoting::pb::EncryptionScheme_CipherMode EncryptionScheme::mode() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.EncryptionScheme.mode)
  return static_cast< ::media::remoting::pb::EncryptionScheme_CipherMode >(mode_);
}
void EncryptionScheme::set_mode(::media::remoting::pb::EncryptionScheme_CipherMode value) {
  assert(::media::remoting::pb::EncryptionScheme_CipherMode_IsValid(value));
  set_has_mode();
  mode_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.EncryptionScheme.mode)
}

// optional uint32 encrypt_blocks = 2;
bool EncryptionScheme::has_encrypt_blocks() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void EncryptionScheme::set_has_encrypt_blocks() {
  _has_bits_[0] |= 0x00000002u;
}
void EncryptionScheme::clear_has_encrypt_blocks() {
  _has_bits_[0] &= ~0x00000002u;
}
void EncryptionScheme::clear_encrypt_blocks() {
  encrypt_blocks_ = 0u;
  clear_has_encrypt_blocks();
}
::google::protobuf::uint32 EncryptionScheme::encrypt_blocks() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.EncryptionScheme.encrypt_blocks)
  return encrypt_blocks_;
}
void EncryptionScheme::set_encrypt_blocks(::google::protobuf::uint32 value) {
  set_has_encrypt_blocks();
  encrypt_blocks_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.EncryptionScheme.encrypt_blocks)
}

// optional uint32 skip_blocks = 3;
bool EncryptionScheme::has_skip_blocks() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void EncryptionScheme::set_has_skip_blocks() {
  _has_bits_[0] |= 0x00000004u;
}
void EncryptionScheme::clear_has_skip_blocks() {
  _has_bits_[0] &= ~0x00000004u;
}
void EncryptionScheme::clear_skip_blocks() {
  skip_blocks_ = 0u;
  clear_has_skip_blocks();
}
::google::protobuf::uint32 EncryptionScheme::skip_blocks() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.EncryptionScheme.skip_blocks)
  return skip_blocks_;
}
void EncryptionScheme::set_skip_blocks(::google::protobuf::uint32 value) {
  set_has_skip_blocks();
  skip_blocks_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.EncryptionScheme.skip_blocks)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int AudioDecoderConfig::kCodecFieldNumber;
const int AudioDecoderConfig::kEncryptionSchemeFieldNumber;
const int AudioDecoderConfig::kSampleFormatFieldNumber;
const int AudioDecoderConfig::kChannelLayoutFieldNumber;
const int AudioDecoderConfig::kSamplesPerSecondFieldNumber;
const int AudioDecoderConfig::kSeekPrerollUsecFieldNumber;
const int AudioDecoderConfig::kCodecDelayFieldNumber;
const int AudioDecoderConfig::kExtraDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

AudioDecoderConfig::AudioDecoderConfig()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.AudioDecoderConfig)
}
AudioDecoderConfig::AudioDecoderConfig(const AudioDecoderConfig& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  extra_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_extra_data()) {
    extra_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.extra_data_);
  }
  if (from.has_encryption_scheme()) {
    encryption_scheme_ = new ::media::remoting::pb::EncryptionScheme(*from.encryption_scheme_);
  } else {
    encryption_scheme_ = NULL;
  }
  ::memcpy(&codec_, &from.codec_,
    static_cast<size_t>(reinterpret_cast<char*>(&codec_delay_) -
    reinterpret_cast<char*>(&codec_)) + sizeof(codec_delay_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.AudioDecoderConfig)
}

void AudioDecoderConfig::SharedCtor() {
  _cached_size_ = 0;
  extra_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&encryption_scheme_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&codec_delay_) -
      reinterpret_cast<char*>(&encryption_scheme_)) + sizeof(codec_delay_));
}

AudioDecoderConfig::~AudioDecoderConfig() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.AudioDecoderConfig)
  SharedDtor();
}

void AudioDecoderConfig::SharedDtor() {
  extra_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete encryption_scheme_;
  }
}

void AudioDecoderConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AudioDecoderConfig& AudioDecoderConfig::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

AudioDecoderConfig* AudioDecoderConfig::New(::google::protobuf::Arena* arena) const {
  AudioDecoderConfig* n = new AudioDecoderConfig;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void AudioDecoderConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.AudioDecoderConfig)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_extra_data()) {
      GOOGLE_DCHECK(!extra_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*extra_data_.UnsafeRawStringPointer())->clear();
    }
    if (has_encryption_scheme()) {
      GOOGLE_DCHECK(encryption_scheme_ != NULL);
      encryption_scheme_->::media::remoting::pb::EncryptionScheme::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 252u) {
    ::memset(&codec_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&codec_delay_) -
        reinterpret_cast<char*>(&codec_)) + sizeof(codec_delay_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool AudioDecoderConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.AudioDecoderConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.AudioDecoderConfig.Codec codec = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::AudioDecoderConfig_Codec_IsValid(value)) {
            set_codec(static_cast< ::media::remoting::pb::AudioDecoderConfig_Codec >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_encryption_scheme()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.AudioDecoderConfig.SampleFormat sample_format = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::AudioDecoderConfig_SampleFormat_IsValid(value)) {
            set_sample_format(static_cast< ::media::remoting::pb::AudioDecoderConfig_SampleFormat >(value));
          } else {
            unknown_fields_stream.WriteVarint32(24u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.AudioDecoderConfig.ChannelLayout channel_layout = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::AudioDecoderConfig_ChannelLayout_IsValid(value)) {
            set_channel_layout(static_cast< ::media::remoting::pb::AudioDecoderConfig_ChannelLayout >(value));
          } else {
            unknown_fields_stream.WriteVarint32(32u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 samples_per_second = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_samples_per_second();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &samples_per_second_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 seek_preroll_usec = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_seek_preroll_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &seek_preroll_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 codec_delay = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u)) {
          set_has_codec_delay();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &codec_delay_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes extra_data = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_extra_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.AudioDecoderConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.AudioDecoderConfig)
  return false;
#undef DO_
}

void AudioDecoderConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.AudioDecoderConfig)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.AudioDecoderConfig.Codec codec = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->codec(), output);
  }

  // optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->encryption_scheme_, output);
  }

  // optional .media.remoting.pb.AudioDecoderConfig.SampleFormat sample_format = 3;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->sample_format(), output);
  }

  // optional .media.remoting.pb.AudioDecoderConfig.ChannelLayout channel_layout = 4;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->channel_layout(), output);
  }

  // optional int32 samples_per_second = 5;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->samples_per_second(), output);
  }

  // optional int64 seek_preroll_usec = 6;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->seek_preroll_usec(), output);
  }

  // optional int32 codec_delay = 7;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->codec_delay(), output);
  }

  // optional bytes extra_data = 8;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      8, this->extra_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.AudioDecoderConfig)
}

size_t AudioDecoderConfig::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.AudioDecoderConfig)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional bytes extra_data = 8;
    if (has_extra_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->extra_data());
    }

    // optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
    if (has_encryption_scheme()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->encryption_scheme_);
    }

    // optional .media.remoting.pb.AudioDecoderConfig.Codec codec = 1;
    if (has_codec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->codec());
    }

    // optional .media.remoting.pb.AudioDecoderConfig.SampleFormat sample_format = 3;
    if (has_sample_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->sample_format());
    }

    // optional .media.remoting.pb.AudioDecoderConfig.ChannelLayout channel_layout = 4;
    if (has_channel_layout()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->channel_layout());
    }

    // optional int32 samples_per_second = 5;
    if (has_samples_per_second()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->samples_per_second());
    }

    // optional int64 seek_preroll_usec = 6;
    if (has_seek_preroll_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->seek_preroll_usec());
    }

    // optional int32 codec_delay = 7;
    if (has_codec_delay()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->codec_delay());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AudioDecoderConfig::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AudioDecoderConfig*>(&from));
}

void AudioDecoderConfig::MergeFrom(const AudioDecoderConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.AudioDecoderConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_extra_data();
      extra_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.extra_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_encryption_scheme()->::media::remoting::pb::EncryptionScheme::MergeFrom(from.encryption_scheme());
    }
    if (cached_has_bits & 0x00000004u) {
      codec_ = from.codec_;
    }
    if (cached_has_bits & 0x00000008u) {
      sample_format_ = from.sample_format_;
    }
    if (cached_has_bits & 0x00000010u) {
      channel_layout_ = from.channel_layout_;
    }
    if (cached_has_bits & 0x00000020u) {
      samples_per_second_ = from.samples_per_second_;
    }
    if (cached_has_bits & 0x00000040u) {
      seek_preroll_usec_ = from.seek_preroll_usec_;
    }
    if (cached_has_bits & 0x00000080u) {
      codec_delay_ = from.codec_delay_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void AudioDecoderConfig::CopyFrom(const AudioDecoderConfig& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.AudioDecoderConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AudioDecoderConfig::IsInitialized() const {
  return true;
}

void AudioDecoderConfig::Swap(AudioDecoderConfig* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AudioDecoderConfig::InternalSwap(AudioDecoderConfig* other) {
  extra_data_.Swap(&other->extra_data_);
  std::swap(encryption_scheme_, other->encryption_scheme_);
  std::swap(codec_, other->codec_);
  std::swap(sample_format_, other->sample_format_);
  std::swap(channel_layout_, other->channel_layout_);
  std::swap(samples_per_second_, other->samples_per_second_);
  std::swap(seek_preroll_usec_, other->seek_preroll_usec_);
  std::swap(codec_delay_, other->codec_delay_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string AudioDecoderConfig::GetTypeName() const {
  return "media.remoting.pb.AudioDecoderConfig";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AudioDecoderConfig

// optional .media.remoting.pb.AudioDecoderConfig.Codec codec = 1;
bool AudioDecoderConfig::has_codec() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void AudioDecoderConfig::set_has_codec() {
  _has_bits_[0] |= 0x00000004u;
}
void AudioDecoderConfig::clear_has_codec() {
  _has_bits_[0] &= ~0x00000004u;
}
void AudioDecoderConfig::clear_codec() {
  codec_ = 0;
  clear_has_codec();
}
::media::remoting::pb::AudioDecoderConfig_Codec AudioDecoderConfig::codec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.codec)
  return static_cast< ::media::remoting::pb::AudioDecoderConfig_Codec >(codec_);
}
void AudioDecoderConfig::set_codec(::media::remoting::pb::AudioDecoderConfig_Codec value) {
  assert(::media::remoting::pb::AudioDecoderConfig_Codec_IsValid(value));
  set_has_codec();
  codec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.codec)
}

// optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
bool AudioDecoderConfig::has_encryption_scheme() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void AudioDecoderConfig::set_has_encryption_scheme() {
  _has_bits_[0] |= 0x00000002u;
}
void AudioDecoderConfig::clear_has_encryption_scheme() {
  _has_bits_[0] &= ~0x00000002u;
}
void AudioDecoderConfig::clear_encryption_scheme() {
  if (encryption_scheme_ != NULL) encryption_scheme_->::media::remoting::pb::EncryptionScheme::Clear();
  clear_has_encryption_scheme();
}
const ::media::remoting::pb::EncryptionScheme& AudioDecoderConfig::encryption_scheme() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.encryption_scheme)
  return encryption_scheme_ != NULL ? *encryption_scheme_
                         : *::media::remoting::pb::EncryptionScheme::internal_default_instance();
}
::media::remoting::pb::EncryptionScheme* AudioDecoderConfig::mutable_encryption_scheme() {
  set_has_encryption_scheme();
  if (encryption_scheme_ == NULL) {
    encryption_scheme_ = new ::media::remoting::pb::EncryptionScheme;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.AudioDecoderConfig.encryption_scheme)
  return encryption_scheme_;
}
::media::remoting::pb::EncryptionScheme* AudioDecoderConfig::release_encryption_scheme() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.AudioDecoderConfig.encryption_scheme)
  clear_has_encryption_scheme();
  ::media::remoting::pb::EncryptionScheme* temp = encryption_scheme_;
  encryption_scheme_ = NULL;
  return temp;
}
void AudioDecoderConfig::set_allocated_encryption_scheme(::media::remoting::pb::EncryptionScheme* encryption_scheme) {
  delete encryption_scheme_;
  encryption_scheme_ = encryption_scheme;
  if (encryption_scheme) {
    set_has_encryption_scheme();
  } else {
    clear_has_encryption_scheme();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.AudioDecoderConfig.encryption_scheme)
}

// optional .media.remoting.pb.AudioDecoderConfig.SampleFormat sample_format = 3;
bool AudioDecoderConfig::has_sample_format() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void AudioDecoderConfig::set_has_sample_format() {
  _has_bits_[0] |= 0x00000008u;
}
void AudioDecoderConfig::clear_has_sample_format() {
  _has_bits_[0] &= ~0x00000008u;
}
void AudioDecoderConfig::clear_sample_format() {
  sample_format_ = 0;
  clear_has_sample_format();
}
::media::remoting::pb::AudioDecoderConfig_SampleFormat AudioDecoderConfig::sample_format() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.sample_format)
  return static_cast< ::media::remoting::pb::AudioDecoderConfig_SampleFormat >(sample_format_);
}
void AudioDecoderConfig::set_sample_format(::media::remoting::pb::AudioDecoderConfig_SampleFormat value) {
  assert(::media::remoting::pb::AudioDecoderConfig_SampleFormat_IsValid(value));
  set_has_sample_format();
  sample_format_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.sample_format)
}

// optional .media.remoting.pb.AudioDecoderConfig.ChannelLayout channel_layout = 4;
bool AudioDecoderConfig::has_channel_layout() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void AudioDecoderConfig::set_has_channel_layout() {
  _has_bits_[0] |= 0x00000010u;
}
void AudioDecoderConfig::clear_has_channel_layout() {
  _has_bits_[0] &= ~0x00000010u;
}
void AudioDecoderConfig::clear_channel_layout() {
  channel_layout_ = 0;
  clear_has_channel_layout();
}
::media::remoting::pb::AudioDecoderConfig_ChannelLayout AudioDecoderConfig::channel_layout() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.channel_layout)
  return static_cast< ::media::remoting::pb::AudioDecoderConfig_ChannelLayout >(channel_layout_);
}
void AudioDecoderConfig::set_channel_layout(::media::remoting::pb::AudioDecoderConfig_ChannelLayout value) {
  assert(::media::remoting::pb::AudioDecoderConfig_ChannelLayout_IsValid(value));
  set_has_channel_layout();
  channel_layout_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.channel_layout)
}

// optional int32 samples_per_second = 5;
bool AudioDecoderConfig::has_samples_per_second() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void AudioDecoderConfig::set_has_samples_per_second() {
  _has_bits_[0] |= 0x00000020u;
}
void AudioDecoderConfig::clear_has_samples_per_second() {
  _has_bits_[0] &= ~0x00000020u;
}
void AudioDecoderConfig::clear_samples_per_second() {
  samples_per_second_ = 0;
  clear_has_samples_per_second();
}
::google::protobuf::int32 AudioDecoderConfig::samples_per_second() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.samples_per_second)
  return samples_per_second_;
}
void AudioDecoderConfig::set_samples_per_second(::google::protobuf::int32 value) {
  set_has_samples_per_second();
  samples_per_second_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.samples_per_second)
}

// optional int64 seek_preroll_usec = 6;
bool AudioDecoderConfig::has_seek_preroll_usec() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void AudioDecoderConfig::set_has_seek_preroll_usec() {
  _has_bits_[0] |= 0x00000040u;
}
void AudioDecoderConfig::clear_has_seek_preroll_usec() {
  _has_bits_[0] &= ~0x00000040u;
}
void AudioDecoderConfig::clear_seek_preroll_usec() {
  seek_preroll_usec_ = GOOGLE_LONGLONG(0);
  clear_has_seek_preroll_usec();
}
::google::protobuf::int64 AudioDecoderConfig::seek_preroll_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.seek_preroll_usec)
  return seek_preroll_usec_;
}
void AudioDecoderConfig::set_seek_preroll_usec(::google::protobuf::int64 value) {
  set_has_seek_preroll_usec();
  seek_preroll_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.seek_preroll_usec)
}

// optional int32 codec_delay = 7;
bool AudioDecoderConfig::has_codec_delay() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void AudioDecoderConfig::set_has_codec_delay() {
  _has_bits_[0] |= 0x00000080u;
}
void AudioDecoderConfig::clear_has_codec_delay() {
  _has_bits_[0] &= ~0x00000080u;
}
void AudioDecoderConfig::clear_codec_delay() {
  codec_delay_ = 0;
  clear_has_codec_delay();
}
::google::protobuf::int32 AudioDecoderConfig::codec_delay() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.codec_delay)
  return codec_delay_;
}
void AudioDecoderConfig::set_codec_delay(::google::protobuf::int32 value) {
  set_has_codec_delay();
  codec_delay_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.codec_delay)
}

// optional bytes extra_data = 8;
bool AudioDecoderConfig::has_extra_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void AudioDecoderConfig::set_has_extra_data() {
  _has_bits_[0] |= 0x00000001u;
}
void AudioDecoderConfig::clear_has_extra_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void AudioDecoderConfig::clear_extra_data() {
  extra_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_extra_data();
}
const ::std::string& AudioDecoderConfig::extra_data() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.AudioDecoderConfig.extra_data)
  return extra_data_.GetNoArena();
}
void AudioDecoderConfig::set_extra_data(const ::std::string& value) {
  set_has_extra_data();
  extra_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.AudioDecoderConfig.extra_data)
}
#if LANG_CXX11
void AudioDecoderConfig::set_extra_data(::std::string&& value) {
  set_has_extra_data();
  extra_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.AudioDecoderConfig.extra_data)
}
#endif
void AudioDecoderConfig::set_extra_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_extra_data();
  extra_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.AudioDecoderConfig.extra_data)
}
void AudioDecoderConfig::set_extra_data(const void* value, size_t size) {
  set_has_extra_data();
  extra_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.AudioDecoderConfig.extra_data)
}
::std::string* AudioDecoderConfig::mutable_extra_data() {
  set_has_extra_data();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.AudioDecoderConfig.extra_data)
  return extra_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* AudioDecoderConfig::release_extra_data() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.AudioDecoderConfig.extra_data)
  clear_has_extra_data();
  return extra_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void AudioDecoderConfig::set_allocated_extra_data(::std::string* extra_data) {
  if (extra_data != NULL) {
    set_has_extra_data();
  } else {
    clear_has_extra_data();
  }
  extra_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), extra_data);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.AudioDecoderConfig.extra_data)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int Rect::kXFieldNumber;
const int Rect::kYFieldNumber;
const int Rect::kWidthFieldNumber;
const int Rect::kHeightFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Rect::Rect()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.Rect)
}
Rect::Rect(const Rect& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&x_, &from.x_,
    static_cast<size_t>(reinterpret_cast<char*>(&height_) -
    reinterpret_cast<char*>(&x_)) + sizeof(height_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.Rect)
}

void Rect::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&x_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&height_) -
      reinterpret_cast<char*>(&x_)) + sizeof(height_));
}

Rect::~Rect() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.Rect)
  SharedDtor();
}

void Rect::SharedDtor() {
}

void Rect::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const Rect& Rect::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

Rect* Rect::New(::google::protobuf::Arena* arena) const {
  Rect* n = new Rect;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void Rect::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.Rect)
  if (_has_bits_[0 / 32] & 15u) {
    ::memset(&x_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&height_) -
        reinterpret_cast<char*>(&x_)) + sizeof(height_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Rect::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.Rect)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 x = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_x();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &x_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 y = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_y();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &y_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 width = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_width();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &width_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 height = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_height();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.Rect)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.Rect)
  return false;
#undef DO_
}

void Rect::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.Rect)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 x = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->x(), output);
  }

  // optional int32 y = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->y(), output);
  }

  // optional int32 width = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->width(), output);
  }

  // optional int32 height = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->height(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.Rect)
}

size_t Rect::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.Rect)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional int32 x = 1;
    if (has_x()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->x());
    }

    // optional int32 y = 2;
    if (has_y()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->y());
    }

    // optional int32 width = 3;
    if (has_width()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->width());
    }

    // optional int32 height = 4;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void Rect::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const Rect*>(&from));
}

void Rect::MergeFrom(const Rect& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.Rect)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      x_ = from.x_;
    }
    if (cached_has_bits & 0x00000002u) {
      y_ = from.y_;
    }
    if (cached_has_bits & 0x00000004u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000008u) {
      height_ = from.height_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Rect::CopyFrom(const Rect& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.Rect)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Rect::IsInitialized() const {
  return true;
}

void Rect::Swap(Rect* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Rect::InternalSwap(Rect* other) {
  std::swap(x_, other->x_);
  std::swap(y_, other->y_);
  std::swap(width_, other->width_);
  std::swap(height_, other->height_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string Rect::GetTypeName() const {
  return "media.remoting.pb.Rect";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// Rect

// optional int32 x = 1;
bool Rect::has_x() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void Rect::set_has_x() {
  _has_bits_[0] |= 0x00000001u;
}
void Rect::clear_has_x() {
  _has_bits_[0] &= ~0x00000001u;
}
void Rect::clear_x() {
  x_ = 0;
  clear_has_x();
}
::google::protobuf::int32 Rect::x() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.Rect.x)
  return x_;
}
void Rect::set_x(::google::protobuf::int32 value) {
  set_has_x();
  x_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.Rect.x)
}

// optional int32 y = 2;
bool Rect::has_y() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void Rect::set_has_y() {
  _has_bits_[0] |= 0x00000002u;
}
void Rect::clear_has_y() {
  _has_bits_[0] &= ~0x00000002u;
}
void Rect::clear_y() {
  y_ = 0;
  clear_has_y();
}
::google::protobuf::int32 Rect::y() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.Rect.y)
  return y_;
}
void Rect::set_y(::google::protobuf::int32 value) {
  set_has_y();
  y_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.Rect.y)
}

// optional int32 width = 3;
bool Rect::has_width() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void Rect::set_has_width() {
  _has_bits_[0] |= 0x00000004u;
}
void Rect::clear_has_width() {
  _has_bits_[0] &= ~0x00000004u;
}
void Rect::clear_width() {
  width_ = 0;
  clear_has_width();
}
::google::protobuf::int32 Rect::width() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.Rect.width)
  return width_;
}
void Rect::set_width(::google::protobuf::int32 value) {
  set_has_width();
  width_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.Rect.width)
}

// optional int32 height = 4;
bool Rect::has_height() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void Rect::set_has_height() {
  _has_bits_[0] |= 0x00000008u;
}
void Rect::clear_has_height() {
  _has_bits_[0] &= ~0x00000008u;
}
void Rect::clear_height() {
  height_ = 0;
  clear_has_height();
}
::google::protobuf::int32 Rect::height() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.Rect.height)
  return height_;
}
void Rect::set_height(::google::protobuf::int32 value) {
  set_has_height();
  height_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.Rect.height)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int VideoDecoderConfig::kCodecFieldNumber;
const int VideoDecoderConfig::kEncryptionSchemeFieldNumber;
const int VideoDecoderConfig::kProfileFieldNumber;
const int VideoDecoderConfig::kFormatFieldNumber;
const int VideoDecoderConfig::kColorSpaceFieldNumber;
const int VideoDecoderConfig::kCodedSizeFieldNumber;
const int VideoDecoderConfig::kVisibleRectFieldNumber;
const int VideoDecoderConfig::kNaturalSizeFieldNumber;
const int VideoDecoderConfig::kExtraDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

VideoDecoderConfig::VideoDecoderConfig()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.VideoDecoderConfig)
}
VideoDecoderConfig::VideoDecoderConfig(const VideoDecoderConfig& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  extra_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_extra_data()) {
    extra_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.extra_data_);
  }
  if (from.has_encryption_scheme()) {
    encryption_scheme_ = new ::media::remoting::pb::EncryptionScheme(*from.encryption_scheme_);
  } else {
    encryption_scheme_ = NULL;
  }
  if (from.has_coded_size()) {
    coded_size_ = new ::media::remoting::pb::Size(*from.coded_size_);
  } else {
    coded_size_ = NULL;
  }
  if (from.has_visible_rect()) {
    visible_rect_ = new ::media::remoting::pb::Rect(*from.visible_rect_);
  } else {
    visible_rect_ = NULL;
  }
  if (from.has_natural_size()) {
    natural_size_ = new ::media::remoting::pb::Size(*from.natural_size_);
  } else {
    natural_size_ = NULL;
  }
  ::memcpy(&codec_, &from.codec_,
    static_cast<size_t>(reinterpret_cast<char*>(&profile_) -
    reinterpret_cast<char*>(&codec_)) + sizeof(profile_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.VideoDecoderConfig)
}

void VideoDecoderConfig::SharedCtor() {
  _cached_size_ = 0;
  extra_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&encryption_scheme_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&color_space_) -
      reinterpret_cast<char*>(&encryption_scheme_)) + sizeof(color_space_));
  profile_ = -1;
}

VideoDecoderConfig::~VideoDecoderConfig() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.VideoDecoderConfig)
  SharedDtor();
}

void VideoDecoderConfig::SharedDtor() {
  extra_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) {
    delete encryption_scheme_;
  }
  if (this != internal_default_instance()) {
    delete coded_size_;
  }
  if (this != internal_default_instance()) {
    delete visible_rect_;
  }
  if (this != internal_default_instance()) {
    delete natural_size_;
  }
}

void VideoDecoderConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const VideoDecoderConfig& VideoDecoderConfig::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

VideoDecoderConfig* VideoDecoderConfig::New(::google::protobuf::Arena* arena) const {
  VideoDecoderConfig* n = new VideoDecoderConfig;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void VideoDecoderConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.VideoDecoderConfig)
  if (_has_bits_[0 / 32] & 31u) {
    if (has_extra_data()) {
      GOOGLE_DCHECK(!extra_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*extra_data_.UnsafeRawStringPointer())->clear();
    }
    if (has_encryption_scheme()) {
      GOOGLE_DCHECK(encryption_scheme_ != NULL);
      encryption_scheme_->::media::remoting::pb::EncryptionScheme::Clear();
    }
    if (has_coded_size()) {
      GOOGLE_DCHECK(coded_size_ != NULL);
      coded_size_->::media::remoting::pb::Size::Clear();
    }
    if (has_visible_rect()) {
      GOOGLE_DCHECK(visible_rect_ != NULL);
      visible_rect_->::media::remoting::pb::Rect::Clear();
    }
    if (has_natural_size()) {
      GOOGLE_DCHECK(natural_size_ != NULL);
      natural_size_->::media::remoting::pb::Size::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 224u) {
    ::memset(&codec_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&color_space_) -
        reinterpret_cast<char*>(&codec_)) + sizeof(color_space_));
  }
  profile_ = -1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool VideoDecoderConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.VideoDecoderConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.VideoDecoderConfig.Codec codec = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::VideoDecoderConfig_Codec_IsValid(value)) {
            set_codec(static_cast< ::media::remoting::pb::VideoDecoderConfig_Codec >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_encryption_scheme()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.VideoDecoderConfig.Profile profile = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::VideoDecoderConfig_Profile_IsValid(value)) {
            set_profile(static_cast< ::media::remoting::pb::VideoDecoderConfig_Profile >(value));
          } else {
            unknown_fields_stream.WriteVarint32(24u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.VideoDecoderConfig.Format format = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::VideoDecoderConfig_Format_IsValid(value)) {
            set_format(static_cast< ::media::remoting::pb::VideoDecoderConfig_Format >(value));
          } else {
            unknown_fields_stream.WriteVarint32(32u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.VideoDecoderConfig.ColorSpace color_space = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::VideoDecoderConfig_ColorSpace_IsValid(value)) {
            set_color_space(static_cast< ::media::remoting::pb::VideoDecoderConfig_ColorSpace >(value));
          } else {
            unknown_fields_stream.WriteVarint32(40u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.Size coded_size = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_coded_size()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.Rect visible_rect = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_visible_rect()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.Size natural_size = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_natural_size()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes extra_data = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_extra_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.VideoDecoderConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.VideoDecoderConfig)
  return false;
#undef DO_
}

void VideoDecoderConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.VideoDecoderConfig)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.VideoDecoderConfig.Codec codec = 1;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->codec(), output);
  }

  // optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->encryption_scheme_, output);
  }

  // optional .media.remoting.pb.VideoDecoderConfig.Profile profile = 3;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      3, this->profile(), output);
  }

  // optional .media.remoting.pb.VideoDecoderConfig.Format format = 4;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->format(), output);
  }

  // optional .media.remoting.pb.VideoDecoderConfig.ColorSpace color_space = 5;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->color_space(), output);
  }

  // optional .media.remoting.pb.Size coded_size = 6;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, *this->coded_size_, output);
  }

  // optional .media.remoting.pb.Rect visible_rect = 7;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, *this->visible_rect_, output);
  }

  // optional .media.remoting.pb.Size natural_size = 8;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      8, *this->natural_size_, output);
  }

  // optional bytes extra_data = 9;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      9, this->extra_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.VideoDecoderConfig)
}

size_t VideoDecoderConfig::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.VideoDecoderConfig)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional bytes extra_data = 9;
    if (has_extra_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->extra_data());
    }

    // optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
    if (has_encryption_scheme()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->encryption_scheme_);
    }

    // optional .media.remoting.pb.Size coded_size = 6;
    if (has_coded_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->coded_size_);
    }

    // optional .media.remoting.pb.Rect visible_rect = 7;
    if (has_visible_rect()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->visible_rect_);
    }

    // optional .media.remoting.pb.Size natural_size = 8;
    if (has_natural_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->natural_size_);
    }

    // optional .media.remoting.pb.VideoDecoderConfig.Codec codec = 1;
    if (has_codec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->codec());
    }

    // optional .media.remoting.pb.VideoDecoderConfig.Format format = 4;
    if (has_format()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->format());
    }

    // optional .media.remoting.pb.VideoDecoderConfig.ColorSpace color_space = 5;
    if (has_color_space()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->color_space());
    }

  }
  // optional .media.remoting.pb.VideoDecoderConfig.Profile profile = 3;
  if (has_profile()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->profile());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void VideoDecoderConfig::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const VideoDecoderConfig*>(&from));
}

void VideoDecoderConfig::MergeFrom(const VideoDecoderConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.VideoDecoderConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_extra_data();
      extra_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.extra_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_encryption_scheme()->::media::remoting::pb::EncryptionScheme::MergeFrom(from.encryption_scheme());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_coded_size()->::media::remoting::pb::Size::MergeFrom(from.coded_size());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_visible_rect()->::media::remoting::pb::Rect::MergeFrom(from.visible_rect());
    }
    if (cached_has_bits & 0x00000010u) {
      mutable_natural_size()->::media::remoting::pb::Size::MergeFrom(from.natural_size());
    }
    if (cached_has_bits & 0x00000020u) {
      codec_ = from.codec_;
    }
    if (cached_has_bits & 0x00000040u) {
      format_ = from.format_;
    }
    if (cached_has_bits & 0x00000080u) {
      color_space_ = from.color_space_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    set_profile(from.profile());
  }
}

void VideoDecoderConfig::CopyFrom(const VideoDecoderConfig& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.VideoDecoderConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool VideoDecoderConfig::IsInitialized() const {
  return true;
}

void VideoDecoderConfig::Swap(VideoDecoderConfig* other) {
  if (other == this) return;
  InternalSwap(other);
}
void VideoDecoderConfig::InternalSwap(VideoDecoderConfig* other) {
  extra_data_.Swap(&other->extra_data_);
  std::swap(encryption_scheme_, other->encryption_scheme_);
  std::swap(coded_size_, other->coded_size_);
  std::swap(visible_rect_, other->visible_rect_);
  std::swap(natural_size_, other->natural_size_);
  std::swap(codec_, other->codec_);
  std::swap(format_, other->format_);
  std::swap(color_space_, other->color_space_);
  std::swap(profile_, other->profile_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string VideoDecoderConfig::GetTypeName() const {
  return "media.remoting.pb.VideoDecoderConfig";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// VideoDecoderConfig

// optional .media.remoting.pb.VideoDecoderConfig.Codec codec = 1;
bool VideoDecoderConfig::has_codec() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void VideoDecoderConfig::set_has_codec() {
  _has_bits_[0] |= 0x00000020u;
}
void VideoDecoderConfig::clear_has_codec() {
  _has_bits_[0] &= ~0x00000020u;
}
void VideoDecoderConfig::clear_codec() {
  codec_ = 0;
  clear_has_codec();
}
::media::remoting::pb::VideoDecoderConfig_Codec VideoDecoderConfig::codec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.codec)
  return static_cast< ::media::remoting::pb::VideoDecoderConfig_Codec >(codec_);
}
void VideoDecoderConfig::set_codec(::media::remoting::pb::VideoDecoderConfig_Codec value) {
  assert(::media::remoting::pb::VideoDecoderConfig_Codec_IsValid(value));
  set_has_codec();
  codec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.VideoDecoderConfig.codec)
}

// optional .media.remoting.pb.EncryptionScheme encryption_scheme = 2;
bool VideoDecoderConfig::has_encryption_scheme() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void VideoDecoderConfig::set_has_encryption_scheme() {
  _has_bits_[0] |= 0x00000002u;
}
void VideoDecoderConfig::clear_has_encryption_scheme() {
  _has_bits_[0] &= ~0x00000002u;
}
void VideoDecoderConfig::clear_encryption_scheme() {
  if (encryption_scheme_ != NULL) encryption_scheme_->::media::remoting::pb::EncryptionScheme::Clear();
  clear_has_encryption_scheme();
}
const ::media::remoting::pb::EncryptionScheme& VideoDecoderConfig::encryption_scheme() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.encryption_scheme)
  return encryption_scheme_ != NULL ? *encryption_scheme_
                         : *::media::remoting::pb::EncryptionScheme::internal_default_instance();
}
::media::remoting::pb::EncryptionScheme* VideoDecoderConfig::mutable_encryption_scheme() {
  set_has_encryption_scheme();
  if (encryption_scheme_ == NULL) {
    encryption_scheme_ = new ::media::remoting::pb::EncryptionScheme;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.VideoDecoderConfig.encryption_scheme)
  return encryption_scheme_;
}
::media::remoting::pb::EncryptionScheme* VideoDecoderConfig::release_encryption_scheme() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.VideoDecoderConfig.encryption_scheme)
  clear_has_encryption_scheme();
  ::media::remoting::pb::EncryptionScheme* temp = encryption_scheme_;
  encryption_scheme_ = NULL;
  return temp;
}
void VideoDecoderConfig::set_allocated_encryption_scheme(::media::remoting::pb::EncryptionScheme* encryption_scheme) {
  delete encryption_scheme_;
  encryption_scheme_ = encryption_scheme;
  if (encryption_scheme) {
    set_has_encryption_scheme();
  } else {
    clear_has_encryption_scheme();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.VideoDecoderConfig.encryption_scheme)
}

// optional .media.remoting.pb.VideoDecoderConfig.Profile profile = 3;
bool VideoDecoderConfig::has_profile() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void VideoDecoderConfig::set_has_profile() {
  _has_bits_[0] |= 0x00000100u;
}
void VideoDecoderConfig::clear_has_profile() {
  _has_bits_[0] &= ~0x00000100u;
}
void VideoDecoderConfig::clear_profile() {
  profile_ = -1;
  clear_has_profile();
}
::media::remoting::pb::VideoDecoderConfig_Profile VideoDecoderConfig::profile() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.profile)
  return static_cast< ::media::remoting::pb::VideoDecoderConfig_Profile >(profile_);
}
void VideoDecoderConfig::set_profile(::media::remoting::pb::VideoDecoderConfig_Profile value) {
  assert(::media::remoting::pb::VideoDecoderConfig_Profile_IsValid(value));
  set_has_profile();
  profile_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.VideoDecoderConfig.profile)
}

// optional .media.remoting.pb.VideoDecoderConfig.Format format = 4;
bool VideoDecoderConfig::has_format() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void VideoDecoderConfig::set_has_format() {
  _has_bits_[0] |= 0x00000040u;
}
void VideoDecoderConfig::clear_has_format() {
  _has_bits_[0] &= ~0x00000040u;
}
void VideoDecoderConfig::clear_format() {
  format_ = 0;
  clear_has_format();
}
::media::remoting::pb::VideoDecoderConfig_Format VideoDecoderConfig::format() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.format)
  return static_cast< ::media::remoting::pb::VideoDecoderConfig_Format >(format_);
}
void VideoDecoderConfig::set_format(::media::remoting::pb::VideoDecoderConfig_Format value) {
  assert(::media::remoting::pb::VideoDecoderConfig_Format_IsValid(value));
  set_has_format();
  format_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.VideoDecoderConfig.format)
}

// optional .media.remoting.pb.VideoDecoderConfig.ColorSpace color_space = 5;
bool VideoDecoderConfig::has_color_space() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void VideoDecoderConfig::set_has_color_space() {
  _has_bits_[0] |= 0x00000080u;
}
void VideoDecoderConfig::clear_has_color_space() {
  _has_bits_[0] &= ~0x00000080u;
}
void VideoDecoderConfig::clear_color_space() {
  color_space_ = 0;
  clear_has_color_space();
}
::media::remoting::pb::VideoDecoderConfig_ColorSpace VideoDecoderConfig::color_space() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.color_space)
  return static_cast< ::media::remoting::pb::VideoDecoderConfig_ColorSpace >(color_space_);
}
void VideoDecoderConfig::set_color_space(::media::remoting::pb::VideoDecoderConfig_ColorSpace value) {
  assert(::media::remoting::pb::VideoDecoderConfig_ColorSpace_IsValid(value));
  set_has_color_space();
  color_space_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.VideoDecoderConfig.color_space)
}

// optional .media.remoting.pb.Size coded_size = 6;
bool VideoDecoderConfig::has_coded_size() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void VideoDecoderConfig::set_has_coded_size() {
  _has_bits_[0] |= 0x00000004u;
}
void VideoDecoderConfig::clear_has_coded_size() {
  _has_bits_[0] &= ~0x00000004u;
}
void VideoDecoderConfig::clear_coded_size() {
  if (coded_size_ != NULL) coded_size_->::media::remoting::pb::Size::Clear();
  clear_has_coded_size();
}
const ::media::remoting::pb::Size& VideoDecoderConfig::coded_size() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.coded_size)
  return coded_size_ != NULL ? *coded_size_
                         : *::media::remoting::pb::Size::internal_default_instance();
}
::media::remoting::pb::Size* VideoDecoderConfig::mutable_coded_size() {
  set_has_coded_size();
  if (coded_size_ == NULL) {
    coded_size_ = new ::media::remoting::pb::Size;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.VideoDecoderConfig.coded_size)
  return coded_size_;
}
::media::remoting::pb::Size* VideoDecoderConfig::release_coded_size() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.VideoDecoderConfig.coded_size)
  clear_has_coded_size();
  ::media::remoting::pb::Size* temp = coded_size_;
  coded_size_ = NULL;
  return temp;
}
void VideoDecoderConfig::set_allocated_coded_size(::media::remoting::pb::Size* coded_size) {
  delete coded_size_;
  coded_size_ = coded_size;
  if (coded_size) {
    set_has_coded_size();
  } else {
    clear_has_coded_size();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.VideoDecoderConfig.coded_size)
}

// optional .media.remoting.pb.Rect visible_rect = 7;
bool VideoDecoderConfig::has_visible_rect() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void VideoDecoderConfig::set_has_visible_rect() {
  _has_bits_[0] |= 0x00000008u;
}
void VideoDecoderConfig::clear_has_visible_rect() {
  _has_bits_[0] &= ~0x00000008u;
}
void VideoDecoderConfig::clear_visible_rect() {
  if (visible_rect_ != NULL) visible_rect_->::media::remoting::pb::Rect::Clear();
  clear_has_visible_rect();
}
const ::media::remoting::pb::Rect& VideoDecoderConfig::visible_rect() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.visible_rect)
  return visible_rect_ != NULL ? *visible_rect_
                         : *::media::remoting::pb::Rect::internal_default_instance();
}
::media::remoting::pb::Rect* VideoDecoderConfig::mutable_visible_rect() {
  set_has_visible_rect();
  if (visible_rect_ == NULL) {
    visible_rect_ = new ::media::remoting::pb::Rect;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.VideoDecoderConfig.visible_rect)
  return visible_rect_;
}
::media::remoting::pb::Rect* VideoDecoderConfig::release_visible_rect() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.VideoDecoderConfig.visible_rect)
  clear_has_visible_rect();
  ::media::remoting::pb::Rect* temp = visible_rect_;
  visible_rect_ = NULL;
  return temp;
}
void VideoDecoderConfig::set_allocated_visible_rect(::media::remoting::pb::Rect* visible_rect) {
  delete visible_rect_;
  visible_rect_ = visible_rect;
  if (visible_rect) {
    set_has_visible_rect();
  } else {
    clear_has_visible_rect();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.VideoDecoderConfig.visible_rect)
}

// optional .media.remoting.pb.Size natural_size = 8;
bool VideoDecoderConfig::has_natural_size() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void VideoDecoderConfig::set_has_natural_size() {
  _has_bits_[0] |= 0x00000010u;
}
void VideoDecoderConfig::clear_has_natural_size() {
  _has_bits_[0] &= ~0x00000010u;
}
void VideoDecoderConfig::clear_natural_size() {
  if (natural_size_ != NULL) natural_size_->::media::remoting::pb::Size::Clear();
  clear_has_natural_size();
}
const ::media::remoting::pb::Size& VideoDecoderConfig::natural_size() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.natural_size)
  return natural_size_ != NULL ? *natural_size_
                         : *::media::remoting::pb::Size::internal_default_instance();
}
::media::remoting::pb::Size* VideoDecoderConfig::mutable_natural_size() {
  set_has_natural_size();
  if (natural_size_ == NULL) {
    natural_size_ = new ::media::remoting::pb::Size;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.VideoDecoderConfig.natural_size)
  return natural_size_;
}
::media::remoting::pb::Size* VideoDecoderConfig::release_natural_size() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.VideoDecoderConfig.natural_size)
  clear_has_natural_size();
  ::media::remoting::pb::Size* temp = natural_size_;
  natural_size_ = NULL;
  return temp;
}
void VideoDecoderConfig::set_allocated_natural_size(::media::remoting::pb::Size* natural_size) {
  delete natural_size_;
  natural_size_ = natural_size;
  if (natural_size) {
    set_has_natural_size();
  } else {
    clear_has_natural_size();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.VideoDecoderConfig.natural_size)
}

// optional bytes extra_data = 9;
bool VideoDecoderConfig::has_extra_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void VideoDecoderConfig::set_has_extra_data() {
  _has_bits_[0] |= 0x00000001u;
}
void VideoDecoderConfig::clear_has_extra_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void VideoDecoderConfig::clear_extra_data() {
  extra_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_extra_data();
}
const ::std::string& VideoDecoderConfig::extra_data() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.VideoDecoderConfig.extra_data)
  return extra_data_.GetNoArena();
}
void VideoDecoderConfig::set_extra_data(const ::std::string& value) {
  set_has_extra_data();
  extra_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.VideoDecoderConfig.extra_data)
}
#if LANG_CXX11
void VideoDecoderConfig::set_extra_data(::std::string&& value) {
  set_has_extra_data();
  extra_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.VideoDecoderConfig.extra_data)
}
#endif
void VideoDecoderConfig::set_extra_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_extra_data();
  extra_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.VideoDecoderConfig.extra_data)
}
void VideoDecoderConfig::set_extra_data(const void* value, size_t size) {
  set_has_extra_data();
  extra_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.VideoDecoderConfig.extra_data)
}
::std::string* VideoDecoderConfig::mutable_extra_data() {
  set_has_extra_data();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.VideoDecoderConfig.extra_data)
  return extra_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* VideoDecoderConfig::release_extra_data() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.VideoDecoderConfig.extra_data)
  clear_has_extra_data();
  return extra_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void VideoDecoderConfig::set_allocated_extra_data(::std::string* extra_data) {
  if (extra_data != NULL) {
    set_has_extra_data();
  } else {
    clear_has_extra_data();
  }
  extra_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), extra_data);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.VideoDecoderConfig.extra_data)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DecryptConfig_SubSample::kClearBytesFieldNumber;
const int DecryptConfig_SubSample::kCypherBytesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DecryptConfig_SubSample::DecryptConfig_SubSample()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.DecryptConfig.SubSample)
}
DecryptConfig_SubSample::DecryptConfig_SubSample(const DecryptConfig_SubSample& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&clear_bytes_, &from.clear_bytes_,
    static_cast<size_t>(reinterpret_cast<char*>(&cypher_bytes_) -
    reinterpret_cast<char*>(&clear_bytes_)) + sizeof(cypher_bytes_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.DecryptConfig.SubSample)
}

void DecryptConfig_SubSample::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&clear_bytes_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&cypher_bytes_) -
      reinterpret_cast<char*>(&clear_bytes_)) + sizeof(cypher_bytes_));
}

DecryptConfig_SubSample::~DecryptConfig_SubSample() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.DecryptConfig.SubSample)
  SharedDtor();
}

void DecryptConfig_SubSample::SharedDtor() {
}

void DecryptConfig_SubSample::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DecryptConfig_SubSample& DecryptConfig_SubSample::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

DecryptConfig_SubSample* DecryptConfig_SubSample::New(::google::protobuf::Arena* arena) const {
  DecryptConfig_SubSample* n = new DecryptConfig_SubSample;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DecryptConfig_SubSample::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.DecryptConfig.SubSample)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&clear_bytes_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&cypher_bytes_) -
        reinterpret_cast<char*>(&clear_bytes_)) + sizeof(cypher_bytes_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DecryptConfig_SubSample::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.DecryptConfig.SubSample)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 clear_bytes = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_clear_bytes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &clear_bytes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 cypher_bytes = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_cypher_bytes();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &cypher_bytes_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.DecryptConfig.SubSample)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.DecryptConfig.SubSample)
  return false;
#undef DO_
}

void DecryptConfig_SubSample::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.DecryptConfig.SubSample)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 clear_bytes = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->clear_bytes(), output);
  }

  // optional uint32 cypher_bytes = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->cypher_bytes(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.DecryptConfig.SubSample)
}

size_t DecryptConfig_SubSample::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.DecryptConfig.SubSample)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional uint32 clear_bytes = 1;
    if (has_clear_bytes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->clear_bytes());
    }

    // optional uint32 cypher_bytes = 2;
    if (has_cypher_bytes()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->cypher_bytes());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DecryptConfig_SubSample::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DecryptConfig_SubSample*>(&from));
}

void DecryptConfig_SubSample::MergeFrom(const DecryptConfig_SubSample& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.DecryptConfig.SubSample)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      clear_bytes_ = from.clear_bytes_;
    }
    if (cached_has_bits & 0x00000002u) {
      cypher_bytes_ = from.cypher_bytes_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DecryptConfig_SubSample::CopyFrom(const DecryptConfig_SubSample& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.DecryptConfig.SubSample)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DecryptConfig_SubSample::IsInitialized() const {
  return true;
}

void DecryptConfig_SubSample::Swap(DecryptConfig_SubSample* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DecryptConfig_SubSample::InternalSwap(DecryptConfig_SubSample* other) {
  std::swap(clear_bytes_, other->clear_bytes_);
  std::swap(cypher_bytes_, other->cypher_bytes_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DecryptConfig_SubSample::GetTypeName() const {
  return "media.remoting.pb.DecryptConfig.SubSample";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DecryptConfig_SubSample

// optional uint32 clear_bytes = 1;
bool DecryptConfig_SubSample::has_clear_bytes() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DecryptConfig_SubSample::set_has_clear_bytes() {
  _has_bits_[0] |= 0x00000001u;
}
void DecryptConfig_SubSample::clear_has_clear_bytes() {
  _has_bits_[0] &= ~0x00000001u;
}
void DecryptConfig_SubSample::clear_clear_bytes() {
  clear_bytes_ = 0u;
  clear_has_clear_bytes();
}
::google::protobuf::uint32 DecryptConfig_SubSample::clear_bytes() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.SubSample.clear_bytes)
  return clear_bytes_;
}
void DecryptConfig_SubSample::set_clear_bytes(::google::protobuf::uint32 value) {
  set_has_clear_bytes();
  clear_bytes_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.SubSample.clear_bytes)
}

// optional uint32 cypher_bytes = 2;
bool DecryptConfig_SubSample::has_cypher_bytes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DecryptConfig_SubSample::set_has_cypher_bytes() {
  _has_bits_[0] |= 0x00000002u;
}
void DecryptConfig_SubSample::clear_has_cypher_bytes() {
  _has_bits_[0] &= ~0x00000002u;
}
void DecryptConfig_SubSample::clear_cypher_bytes() {
  cypher_bytes_ = 0u;
  clear_has_cypher_bytes();
}
::google::protobuf::uint32 DecryptConfig_SubSample::cypher_bytes() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.SubSample.cypher_bytes)
  return cypher_bytes_;
}
void DecryptConfig_SubSample::set_cypher_bytes(::google::protobuf::uint32 value) {
  set_has_cypher_bytes();
  cypher_bytes_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.SubSample.cypher_bytes)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DecryptConfig::kKeyIdFieldNumber;
const int DecryptConfig::kIvFieldNumber;
const int DecryptConfig::kSubSamplesFieldNumber;
const int DecryptConfig::kModeFieldNumber;
const int DecryptConfig::kCryptByteBlockFieldNumber;
const int DecryptConfig::kSkipByteBlockFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DecryptConfig::DecryptConfig()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.DecryptConfig)
}
DecryptConfig::DecryptConfig(const DecryptConfig& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      sub_samples_(from.sub_samples_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_key_id()) {
    key_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_id_);
  }
  iv_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_iv()) {
    iv_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.iv_);
  }
  ::memcpy(&mode_, &from.mode_,
    static_cast<size_t>(reinterpret_cast<char*>(&skip_byte_block_) -
    reinterpret_cast<char*>(&mode_)) + sizeof(skip_byte_block_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.DecryptConfig)
}

void DecryptConfig::SharedCtor() {
  _cached_size_ = 0;
  key_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  iv_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&mode_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&skip_byte_block_) -
      reinterpret_cast<char*>(&mode_)) + sizeof(skip_byte_block_));
}

DecryptConfig::~DecryptConfig() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.DecryptConfig)
  SharedDtor();
}

void DecryptConfig::SharedDtor() {
  key_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  iv_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DecryptConfig::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DecryptConfig& DecryptConfig::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

DecryptConfig* DecryptConfig::New(::google::protobuf::Arena* arena) const {
  DecryptConfig* n = new DecryptConfig;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DecryptConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.DecryptConfig)
  sub_samples_.Clear();
  if (_has_bits_[0 / 32] & 3u) {
    if (has_key_id()) {
      GOOGLE_DCHECK(!key_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*key_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_iv()) {
      GOOGLE_DCHECK(!iv_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*iv_.UnsafeRawStringPointer())->clear();
    }
  }
  if (_has_bits_[0 / 32] & 28u) {
    ::memset(&mode_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&skip_byte_block_) -
        reinterpret_cast<char*>(&mode_)) + sizeof(skip_byte_block_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DecryptConfig::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.DecryptConfig)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes key_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_key_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes iv = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_iv()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .media.remoting.pb.DecryptConfig.SubSample sub_samples = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_sub_samples()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.EncryptionMode mode = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::EncryptionMode_IsValid(value)) {
            set_mode(static_cast< ::media::remoting::pb::EncryptionMode >(value));
          } else {
            unknown_fields_stream.WriteVarint32(32u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 crypt_byte_block = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_crypt_byte_block();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &crypt_byte_block_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 skip_byte_block = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_skip_byte_block();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &skip_byte_block_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.DecryptConfig)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.DecryptConfig)
  return false;
#undef DO_
}

void DecryptConfig::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.DecryptConfig)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes key_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->key_id(), output);
  }

  // optional bytes iv = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->iv(), output);
  }

  // repeated .media.remoting.pb.DecryptConfig.SubSample sub_samples = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->sub_samples_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->sub_samples(static_cast<int>(i)), output);
  }

  // optional .media.remoting.pb.EncryptionMode mode = 4;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->mode(), output);
  }

  // optional uint32 crypt_byte_block = 5;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->crypt_byte_block(), output);
  }

  // optional uint32 skip_byte_block = 6;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->skip_byte_block(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.DecryptConfig)
}

size_t DecryptConfig::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.DecryptConfig)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated .media.remoting.pb.DecryptConfig.SubSample sub_samples = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->sub_samples_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->sub_samples(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 31u) {
    // optional bytes key_id = 1;
    if (has_key_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->key_id());
    }

    // optional bytes iv = 2;
    if (has_iv()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->iv());
    }

    // optional .media.remoting.pb.EncryptionMode mode = 4;
    if (has_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->mode());
    }

    // optional uint32 crypt_byte_block = 5;
    if (has_crypt_byte_block()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->crypt_byte_block());
    }

    // optional uint32 skip_byte_block = 6;
    if (has_skip_byte_block()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->skip_byte_block());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DecryptConfig::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DecryptConfig*>(&from));
}

void DecryptConfig::MergeFrom(const DecryptConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.DecryptConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  sub_samples_.MergeFrom(from.sub_samples_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_key_id();
      key_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_iv();
      iv_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.iv_);
    }
    if (cached_has_bits & 0x00000004u) {
      mode_ = from.mode_;
    }
    if (cached_has_bits & 0x00000008u) {
      crypt_byte_block_ = from.crypt_byte_block_;
    }
    if (cached_has_bits & 0x00000010u) {
      skip_byte_block_ = from.skip_byte_block_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DecryptConfig::CopyFrom(const DecryptConfig& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.DecryptConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DecryptConfig::IsInitialized() const {
  return true;
}

void DecryptConfig::Swap(DecryptConfig* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DecryptConfig::InternalSwap(DecryptConfig* other) {
  sub_samples_.InternalSwap(&other->sub_samples_);
  key_id_.Swap(&other->key_id_);
  iv_.Swap(&other->iv_);
  std::swap(mode_, other->mode_);
  std::swap(crypt_byte_block_, other->crypt_byte_block_);
  std::swap(skip_byte_block_, other->skip_byte_block_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DecryptConfig::GetTypeName() const {
  return "media.remoting.pb.DecryptConfig";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DecryptConfig

// optional bytes key_id = 1;
bool DecryptConfig::has_key_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DecryptConfig::set_has_key_id() {
  _has_bits_[0] |= 0x00000001u;
}
void DecryptConfig::clear_has_key_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void DecryptConfig::clear_key_id() {
  key_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key_id();
}
const ::std::string& DecryptConfig::key_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.key_id)
  return key_id_.GetNoArena();
}
void DecryptConfig::set_key_id(const ::std::string& value) {
  set_has_key_id();
  key_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.key_id)
}
#if LANG_CXX11
void DecryptConfig::set_key_id(::std::string&& value) {
  set_has_key_id();
  key_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.DecryptConfig.key_id)
}
#endif
void DecryptConfig::set_key_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key_id();
  key_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.DecryptConfig.key_id)
}
void DecryptConfig::set_key_id(const void* value, size_t size) {
  set_has_key_id();
  key_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.DecryptConfig.key_id)
}
::std::string* DecryptConfig::mutable_key_id() {
  set_has_key_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DecryptConfig.key_id)
  return key_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DecryptConfig::release_key_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DecryptConfig.key_id)
  clear_has_key_id();
  return key_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DecryptConfig::set_allocated_key_id(::std::string* key_id) {
  if (key_id != NULL) {
    set_has_key_id();
  } else {
    clear_has_key_id();
  }
  key_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DecryptConfig.key_id)
}

// optional bytes iv = 2;
bool DecryptConfig::has_iv() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DecryptConfig::set_has_iv() {
  _has_bits_[0] |= 0x00000002u;
}
void DecryptConfig::clear_has_iv() {
  _has_bits_[0] &= ~0x00000002u;
}
void DecryptConfig::clear_iv() {
  iv_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_iv();
}
const ::std::string& DecryptConfig::iv() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.iv)
  return iv_.GetNoArena();
}
void DecryptConfig::set_iv(const ::std::string& value) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.iv)
}
#if LANG_CXX11
void DecryptConfig::set_iv(::std::string&& value) {
  set_has_iv();
  iv_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.DecryptConfig.iv)
}
#endif
void DecryptConfig::set_iv(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.DecryptConfig.iv)
}
void DecryptConfig::set_iv(const void* value, size_t size) {
  set_has_iv();
  iv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.DecryptConfig.iv)
}
::std::string* DecryptConfig::mutable_iv() {
  set_has_iv();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DecryptConfig.iv)
  return iv_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DecryptConfig::release_iv() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DecryptConfig.iv)
  clear_has_iv();
  return iv_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DecryptConfig::set_allocated_iv(::std::string* iv) {
  if (iv != NULL) {
    set_has_iv();
  } else {
    clear_has_iv();
  }
  iv_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), iv);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DecryptConfig.iv)
}

// repeated .media.remoting.pb.DecryptConfig.SubSample sub_samples = 3;
int DecryptConfig::sub_samples_size() const {
  return sub_samples_.size();
}
void DecryptConfig::clear_sub_samples() {
  sub_samples_.Clear();
}
const ::media::remoting::pb::DecryptConfig_SubSample& DecryptConfig::sub_samples(int index) const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.sub_samples)
  return sub_samples_.Get(index);
}
::media::remoting::pb::DecryptConfig_SubSample* DecryptConfig::mutable_sub_samples(int index) {
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DecryptConfig.sub_samples)
  return sub_samples_.Mutable(index);
}
::media::remoting::pb::DecryptConfig_SubSample* DecryptConfig::add_sub_samples() {
  // @@protoc_insertion_point(field_add:media.remoting.pb.DecryptConfig.sub_samples)
  return sub_samples_.Add();
}
::google::protobuf::RepeatedPtrField< ::media::remoting::pb::DecryptConfig_SubSample >*
DecryptConfig::mutable_sub_samples() {
  // @@protoc_insertion_point(field_mutable_list:media.remoting.pb.DecryptConfig.sub_samples)
  return &sub_samples_;
}
const ::google::protobuf::RepeatedPtrField< ::media::remoting::pb::DecryptConfig_SubSample >&
DecryptConfig::sub_samples() const {
  // @@protoc_insertion_point(field_list:media.remoting.pb.DecryptConfig.sub_samples)
  return sub_samples_;
}

// optional .media.remoting.pb.EncryptionMode mode = 4;
bool DecryptConfig::has_mode() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void DecryptConfig::set_has_mode() {
  _has_bits_[0] |= 0x00000004u;
}
void DecryptConfig::clear_has_mode() {
  _has_bits_[0] &= ~0x00000004u;
}
void DecryptConfig::clear_mode() {
  mode_ = 0;
  clear_has_mode();
}
::media::remoting::pb::EncryptionMode DecryptConfig::mode() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.mode)
  return static_cast< ::media::remoting::pb::EncryptionMode >(mode_);
}
void DecryptConfig::set_mode(::media::remoting::pb::EncryptionMode value) {
  assert(::media::remoting::pb::EncryptionMode_IsValid(value));
  set_has_mode();
  mode_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.mode)
}

// optional uint32 crypt_byte_block = 5;
bool DecryptConfig::has_crypt_byte_block() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void DecryptConfig::set_has_crypt_byte_block() {
  _has_bits_[0] |= 0x00000008u;
}
void DecryptConfig::clear_has_crypt_byte_block() {
  _has_bits_[0] &= ~0x00000008u;
}
void DecryptConfig::clear_crypt_byte_block() {
  crypt_byte_block_ = 0u;
  clear_has_crypt_byte_block();
}
::google::protobuf::uint32 DecryptConfig::crypt_byte_block() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.crypt_byte_block)
  return crypt_byte_block_;
}
void DecryptConfig::set_crypt_byte_block(::google::protobuf::uint32 value) {
  set_has_crypt_byte_block();
  crypt_byte_block_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.crypt_byte_block)
}

// optional uint32 skip_byte_block = 6;
bool DecryptConfig::has_skip_byte_block() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void DecryptConfig::set_has_skip_byte_block() {
  _has_bits_[0] |= 0x00000010u;
}
void DecryptConfig::clear_has_skip_byte_block() {
  _has_bits_[0] &= ~0x00000010u;
}
void DecryptConfig::clear_skip_byte_block() {
  skip_byte_block_ = 0u;
  clear_has_skip_byte_block();
}
::google::protobuf::uint32 DecryptConfig::skip_byte_block() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DecryptConfig.skip_byte_block)
  return skip_byte_block_;
}
void DecryptConfig::set_skip_byte_block(::google::protobuf::uint32 value) {
  set_has_skip_byte_block();
  skip_byte_block_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DecryptConfig.skip_byte_block)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PipelineStatistics::kAudioBytesDecodedFieldNumber;
const int PipelineStatistics::kVideoBytesDecodedFieldNumber;
const int PipelineStatistics::kVideoFramesDecodedFieldNumber;
const int PipelineStatistics::kVideoFramesDroppedFieldNumber;
const int PipelineStatistics::kAudioMemoryUsageFieldNumber;
const int PipelineStatistics::kVideoMemoryUsageFieldNumber;
const int PipelineStatistics::kVideoFrameDurationAverageUsecFieldNumber;
const int PipelineStatistics::kAudioDecoderNameFieldNumber;
const int PipelineStatistics::kVideoDecoderNameFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PipelineStatistics::PipelineStatistics()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.PipelineStatistics)
}
PipelineStatistics::PipelineStatistics(const PipelineStatistics& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  audio_decoder_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_audio_decoder_name()) {
    audio_decoder_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.audio_decoder_name_);
  }
  video_decoder_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_video_decoder_name()) {
    video_decoder_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.video_decoder_name_);
  }
  ::memcpy(&audio_bytes_decoded_, &from.audio_bytes_decoded_,
    static_cast<size_t>(reinterpret_cast<char*>(&video_frame_duration_average_usec_) -
    reinterpret_cast<char*>(&audio_bytes_decoded_)) + sizeof(video_frame_duration_average_usec_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.PipelineStatistics)
}

void PipelineStatistics::SharedCtor() {
  _cached_size_ = 0;
  audio_decoder_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  video_decoder_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&audio_bytes_decoded_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&video_frame_duration_average_usec_) -
      reinterpret_cast<char*>(&audio_bytes_decoded_)) + sizeof(video_frame_duration_average_usec_));
}

PipelineStatistics::~PipelineStatistics() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.PipelineStatistics)
  SharedDtor();
}

void PipelineStatistics::SharedDtor() {
  audio_decoder_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  video_decoder_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void PipelineStatistics::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PipelineStatistics& PipelineStatistics::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

PipelineStatistics* PipelineStatistics::New(::google::protobuf::Arena* arena) const {
  PipelineStatistics* n = new PipelineStatistics;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PipelineStatistics::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.PipelineStatistics)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_audio_decoder_name()) {
      GOOGLE_DCHECK(!audio_decoder_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*audio_decoder_name_.UnsafeRawStringPointer())->clear();
    }
    if (has_video_decoder_name()) {
      GOOGLE_DCHECK(!video_decoder_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*video_decoder_name_.UnsafeRawStringPointer())->clear();
    }
  }
  if (_has_bits_[0 / 32] & 252u) {
    ::memset(&audio_bytes_decoded_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&video_memory_usage_) -
        reinterpret_cast<char*>(&audio_bytes_decoded_)) + sizeof(video_memory_usage_));
  }
  video_frame_duration_average_usec_ = GOOGLE_LONGLONG(0);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PipelineStatistics::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.PipelineStatistics)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint64 audio_bytes_decoded = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_audio_bytes_decoded();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &audio_bytes_decoded_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 video_bytes_decoded = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_video_bytes_decoded();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &video_bytes_decoded_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 video_frames_decoded = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_video_frames_decoded();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &video_frames_decoded_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 video_frames_dropped = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_video_frames_dropped();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &video_frames_dropped_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 audio_memory_usage = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_audio_memory_usage();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &audio_memory_usage_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 video_memory_usage = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_video_memory_usage();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &video_memory_usage_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 video_frame_duration_average_usec = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u)) {
          set_has_video_frame_duration_average_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &video_frame_duration_average_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string audio_decoder_name = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_audio_decoder_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string video_decoder_name = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_video_decoder_name()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.PipelineStatistics)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.PipelineStatistics)
  return false;
#undef DO_
}

void PipelineStatistics::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.PipelineStatistics)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint64 audio_bytes_decoded = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->audio_bytes_decoded(), output);
  }

  // optional uint64 video_bytes_decoded = 2;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->video_bytes_decoded(), output);
  }

  // optional uint32 video_frames_decoded = 3;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->video_frames_decoded(), output);
  }

  // optional uint32 video_frames_dropped = 4;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->video_frames_dropped(), output);
  }

  // optional int64 audio_memory_usage = 5;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->audio_memory_usage(), output);
  }

  // optional int64 video_memory_usage = 6;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(6, this->video_memory_usage(), output);
  }

  // optional int64 video_frame_duration_average_usec = 7;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(7, this->video_frame_duration_average_usec(), output);
  }

  // optional string audio_decoder_name = 8;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      8, this->audio_decoder_name(), output);
  }

  // optional string video_decoder_name = 9;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      9, this->video_decoder_name(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.PipelineStatistics)
}

size_t PipelineStatistics::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.PipelineStatistics)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional string audio_decoder_name = 8;
    if (has_audio_decoder_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->audio_decoder_name());
    }

    // optional string video_decoder_name = 9;
    if (has_video_decoder_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->video_decoder_name());
    }

    // optional uint64 audio_bytes_decoded = 1;
    if (has_audio_bytes_decoded()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->audio_bytes_decoded());
    }

    // optional uint64 video_bytes_decoded = 2;
    if (has_video_bytes_decoded()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->video_bytes_decoded());
    }

    // optional uint32 video_frames_decoded = 3;
    if (has_video_frames_decoded()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->video_frames_decoded());
    }

    // optional uint32 video_frames_dropped = 4;
    if (has_video_frames_dropped()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->video_frames_dropped());
    }

    // optional int64 audio_memory_usage = 5;
    if (has_audio_memory_usage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->audio_memory_usage());
    }

    // optional int64 video_memory_usage = 6;
    if (has_video_memory_usage()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->video_memory_usage());
    }

  }
  // optional int64 video_frame_duration_average_usec = 7;
  if (has_video_frame_duration_average_usec()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::Int64Size(
        this->video_frame_duration_average_usec());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PipelineStatistics::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PipelineStatistics*>(&from));
}

void PipelineStatistics::MergeFrom(const PipelineStatistics& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.PipelineStatistics)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_audio_decoder_name();
      audio_decoder_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.audio_decoder_name_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_video_decoder_name();
      video_decoder_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.video_decoder_name_);
    }
    if (cached_has_bits & 0x00000004u) {
      audio_bytes_decoded_ = from.audio_bytes_decoded_;
    }
    if (cached_has_bits & 0x00000008u) {
      video_bytes_decoded_ = from.video_bytes_decoded_;
    }
    if (cached_has_bits & 0x00000010u) {
      video_frames_decoded_ = from.video_frames_decoded_;
    }
    if (cached_has_bits & 0x00000020u) {
      video_frames_dropped_ = from.video_frames_dropped_;
    }
    if (cached_has_bits & 0x00000040u) {
      audio_memory_usage_ = from.audio_memory_usage_;
    }
    if (cached_has_bits & 0x00000080u) {
      video_memory_usage_ = from.video_memory_usage_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    set_video_frame_duration_average_usec(from.video_frame_duration_average_usec());
  }
}

void PipelineStatistics::CopyFrom(const PipelineStatistics& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.PipelineStatistics)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PipelineStatistics::IsInitialized() const {
  return true;
}

void PipelineStatistics::Swap(PipelineStatistics* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PipelineStatistics::InternalSwap(PipelineStatistics* other) {
  audio_decoder_name_.Swap(&other->audio_decoder_name_);
  video_decoder_name_.Swap(&other->video_decoder_name_);
  std::swap(audio_bytes_decoded_, other->audio_bytes_decoded_);
  std::swap(video_bytes_decoded_, other->video_bytes_decoded_);
  std::swap(video_frames_decoded_, other->video_frames_decoded_);
  std::swap(video_frames_dropped_, other->video_frames_dropped_);
  std::swap(audio_memory_usage_, other->audio_memory_usage_);
  std::swap(video_memory_usage_, other->video_memory_usage_);
  std::swap(video_frame_duration_average_usec_, other->video_frame_duration_average_usec_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PipelineStatistics::GetTypeName() const {
  return "media.remoting.pb.PipelineStatistics";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// PipelineStatistics

// optional uint64 audio_bytes_decoded = 1;
bool PipelineStatistics::has_audio_bytes_decoded() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void PipelineStatistics::set_has_audio_bytes_decoded() {
  _has_bits_[0] |= 0x00000004u;
}
void PipelineStatistics::clear_has_audio_bytes_decoded() {
  _has_bits_[0] &= ~0x00000004u;
}
void PipelineStatistics::clear_audio_bytes_decoded() {
  audio_bytes_decoded_ = GOOGLE_ULONGLONG(0);
  clear_has_audio_bytes_decoded();
}
::google::protobuf::uint64 PipelineStatistics::audio_bytes_decoded() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.audio_bytes_decoded)
  return audio_bytes_decoded_;
}
void PipelineStatistics::set_audio_bytes_decoded(::google::protobuf::uint64 value) {
  set_has_audio_bytes_decoded();
  audio_bytes_decoded_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.audio_bytes_decoded)
}

// optional uint64 video_bytes_decoded = 2;
bool PipelineStatistics::has_video_bytes_decoded() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void PipelineStatistics::set_has_video_bytes_decoded() {
  _has_bits_[0] |= 0x00000008u;
}
void PipelineStatistics::clear_has_video_bytes_decoded() {
  _has_bits_[0] &= ~0x00000008u;
}
void PipelineStatistics::clear_video_bytes_decoded() {
  video_bytes_decoded_ = GOOGLE_ULONGLONG(0);
  clear_has_video_bytes_decoded();
}
::google::protobuf::uint64 PipelineStatistics::video_bytes_decoded() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.video_bytes_decoded)
  return video_bytes_decoded_;
}
void PipelineStatistics::set_video_bytes_decoded(::google::protobuf::uint64 value) {
  set_has_video_bytes_decoded();
  video_bytes_decoded_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.video_bytes_decoded)
}

// optional uint32 video_frames_decoded = 3;
bool PipelineStatistics::has_video_frames_decoded() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void PipelineStatistics::set_has_video_frames_decoded() {
  _has_bits_[0] |= 0x00000010u;
}
void PipelineStatistics::clear_has_video_frames_decoded() {
  _has_bits_[0] &= ~0x00000010u;
}
void PipelineStatistics::clear_video_frames_decoded() {
  video_frames_decoded_ = 0u;
  clear_has_video_frames_decoded();
}
::google::protobuf::uint32 PipelineStatistics::video_frames_decoded() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.video_frames_decoded)
  return video_frames_decoded_;
}
void PipelineStatistics::set_video_frames_decoded(::google::protobuf::uint32 value) {
  set_has_video_frames_decoded();
  video_frames_decoded_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.video_frames_decoded)
}

// optional uint32 video_frames_dropped = 4;
bool PipelineStatistics::has_video_frames_dropped() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void PipelineStatistics::set_has_video_frames_dropped() {
  _has_bits_[0] |= 0x00000020u;
}
void PipelineStatistics::clear_has_video_frames_dropped() {
  _has_bits_[0] &= ~0x00000020u;
}
void PipelineStatistics::clear_video_frames_dropped() {
  video_frames_dropped_ = 0u;
  clear_has_video_frames_dropped();
}
::google::protobuf::uint32 PipelineStatistics::video_frames_dropped() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.video_frames_dropped)
  return video_frames_dropped_;
}
void PipelineStatistics::set_video_frames_dropped(::google::protobuf::uint32 value) {
  set_has_video_frames_dropped();
  video_frames_dropped_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.video_frames_dropped)
}

// optional int64 audio_memory_usage = 5;
bool PipelineStatistics::has_audio_memory_usage() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void PipelineStatistics::set_has_audio_memory_usage() {
  _has_bits_[0] |= 0x00000040u;
}
void PipelineStatistics::clear_has_audio_memory_usage() {
  _has_bits_[0] &= ~0x00000040u;
}
void PipelineStatistics::clear_audio_memory_usage() {
  audio_memory_usage_ = GOOGLE_LONGLONG(0);
  clear_has_audio_memory_usage();
}
::google::protobuf::int64 PipelineStatistics::audio_memory_usage() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.audio_memory_usage)
  return audio_memory_usage_;
}
void PipelineStatistics::set_audio_memory_usage(::google::protobuf::int64 value) {
  set_has_audio_memory_usage();
  audio_memory_usage_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.audio_memory_usage)
}

// optional int64 video_memory_usage = 6;
bool PipelineStatistics::has_video_memory_usage() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void PipelineStatistics::set_has_video_memory_usage() {
  _has_bits_[0] |= 0x00000080u;
}
void PipelineStatistics::clear_has_video_memory_usage() {
  _has_bits_[0] &= ~0x00000080u;
}
void PipelineStatistics::clear_video_memory_usage() {
  video_memory_usage_ = GOOGLE_LONGLONG(0);
  clear_has_video_memory_usage();
}
::google::protobuf::int64 PipelineStatistics::video_memory_usage() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.video_memory_usage)
  return video_memory_usage_;
}
void PipelineStatistics::set_video_memory_usage(::google::protobuf::int64 value) {
  set_has_video_memory_usage();
  video_memory_usage_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.video_memory_usage)
}

// optional int64 video_frame_duration_average_usec = 7;
bool PipelineStatistics::has_video_frame_duration_average_usec() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void PipelineStatistics::set_has_video_frame_duration_average_usec() {
  _has_bits_[0] |= 0x00000100u;
}
void PipelineStatistics::clear_has_video_frame_duration_average_usec() {
  _has_bits_[0] &= ~0x00000100u;
}
void PipelineStatistics::clear_video_frame_duration_average_usec() {
  video_frame_duration_average_usec_ = GOOGLE_LONGLONG(0);
  clear_has_video_frame_duration_average_usec();
}
::google::protobuf::int64 PipelineStatistics::video_frame_duration_average_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.video_frame_duration_average_usec)
  return video_frame_duration_average_usec_;
}
void PipelineStatistics::set_video_frame_duration_average_usec(::google::protobuf::int64 value) {
  set_has_video_frame_duration_average_usec();
  video_frame_duration_average_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.video_frame_duration_average_usec)
}

// optional string audio_decoder_name = 8;
bool PipelineStatistics::has_audio_decoder_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void PipelineStatistics::set_has_audio_decoder_name() {
  _has_bits_[0] |= 0x00000001u;
}
void PipelineStatistics::clear_has_audio_decoder_name() {
  _has_bits_[0] &= ~0x00000001u;
}
void PipelineStatistics::clear_audio_decoder_name() {
  audio_decoder_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_audio_decoder_name();
}
const ::std::string& PipelineStatistics::audio_decoder_name() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.audio_decoder_name)
  return audio_decoder_name_.GetNoArena();
}
void PipelineStatistics::set_audio_decoder_name(const ::std::string& value) {
  set_has_audio_decoder_name();
  audio_decoder_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.audio_decoder_name)
}
#if LANG_CXX11
void PipelineStatistics::set_audio_decoder_name(::std::string&& value) {
  set_has_audio_decoder_name();
  audio_decoder_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.PipelineStatistics.audio_decoder_name)
}
#endif
void PipelineStatistics::set_audio_decoder_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_audio_decoder_name();
  audio_decoder_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.PipelineStatistics.audio_decoder_name)
}
void PipelineStatistics::set_audio_decoder_name(const char* value, size_t size) {
  set_has_audio_decoder_name();
  audio_decoder_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.PipelineStatistics.audio_decoder_name)
}
::std::string* PipelineStatistics::mutable_audio_decoder_name() {
  set_has_audio_decoder_name();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.PipelineStatistics.audio_decoder_name)
  return audio_decoder_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* PipelineStatistics::release_audio_decoder_name() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.PipelineStatistics.audio_decoder_name)
  clear_has_audio_decoder_name();
  return audio_decoder_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void PipelineStatistics::set_allocated_audio_decoder_name(::std::string* audio_decoder_name) {
  if (audio_decoder_name != NULL) {
    set_has_audio_decoder_name();
  } else {
    clear_has_audio_decoder_name();
  }
  audio_decoder_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), audio_decoder_name);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.PipelineStatistics.audio_decoder_name)
}

// optional string video_decoder_name = 9;
bool PipelineStatistics::has_video_decoder_name() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void PipelineStatistics::set_has_video_decoder_name() {
  _has_bits_[0] |= 0x00000002u;
}
void PipelineStatistics::clear_has_video_decoder_name() {
  _has_bits_[0] &= ~0x00000002u;
}
void PipelineStatistics::clear_video_decoder_name() {
  video_decoder_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_video_decoder_name();
}
const ::std::string& PipelineStatistics::video_decoder_name() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.PipelineStatistics.video_decoder_name)
  return video_decoder_name_.GetNoArena();
}
void PipelineStatistics::set_video_decoder_name(const ::std::string& value) {
  set_has_video_decoder_name();
  video_decoder_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.PipelineStatistics.video_decoder_name)
}
#if LANG_CXX11
void PipelineStatistics::set_video_decoder_name(::std::string&& value) {
  set_has_video_decoder_name();
  video_decoder_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.PipelineStatistics.video_decoder_name)
}
#endif
void PipelineStatistics::set_video_decoder_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_video_decoder_name();
  video_decoder_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.PipelineStatistics.video_decoder_name)
}
void PipelineStatistics::set_video_decoder_name(const char* value, size_t size) {
  set_has_video_decoder_name();
  video_decoder_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.PipelineStatistics.video_decoder_name)
}
::std::string* PipelineStatistics::mutable_video_decoder_name() {
  set_has_video_decoder_name();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.PipelineStatistics.video_decoder_name)
  return video_decoder_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* PipelineStatistics::release_video_decoder_name() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.PipelineStatistics.video_decoder_name)
  clear_has_video_decoder_name();
  return video_decoder_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void PipelineStatistics::set_allocated_video_decoder_name(::std::string* video_decoder_name) {
  if (video_decoder_name != NULL) {
    set_has_video_decoder_name();
  } else {
    clear_has_video_decoder_name();
  }
  video_decoder_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), video_decoder_name);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.PipelineStatistics.video_decoder_name)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmKeyInformation::kKeyIdFieldNumber;
const int CdmKeyInformation::kStatusFieldNumber;
const int CdmKeyInformation::kSystemCodeFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmKeyInformation::CdmKeyInformation()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmKeyInformation)
}
CdmKeyInformation::CdmKeyInformation(const CdmKeyInformation& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_key_id()) {
    key_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_id_);
  }
  ::memcpy(&status_, &from.status_,
    static_cast<size_t>(reinterpret_cast<char*>(&system_code_) -
    reinterpret_cast<char*>(&status_)) + sizeof(system_code_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmKeyInformation)
}

void CdmKeyInformation::SharedCtor() {
  _cached_size_ = 0;
  key_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&status_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&system_code_) -
      reinterpret_cast<char*>(&status_)) + sizeof(system_code_));
}

CdmKeyInformation::~CdmKeyInformation() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmKeyInformation)
  SharedDtor();
}

void CdmKeyInformation::SharedDtor() {
  key_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmKeyInformation::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmKeyInformation& CdmKeyInformation::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmKeyInformation* CdmKeyInformation::New(::google::protobuf::Arena* arena) const {
  CdmKeyInformation* n = new CdmKeyInformation;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmKeyInformation::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmKeyInformation)
  if (has_key_id()) {
    GOOGLE_DCHECK(!key_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*key_id_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 6u) {
    ::memset(&status_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&system_code_) -
        reinterpret_cast<char*>(&status_)) + sizeof(system_code_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmKeyInformation::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmKeyInformation)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bytes key_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_key_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmKeyInformation.KeyStatus status = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::CdmKeyInformation_KeyStatus_IsValid(value)) {
            set_status(static_cast< ::media::remoting::pb::CdmKeyInformation_KeyStatus >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 system_code = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_system_code();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &system_code_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmKeyInformation)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmKeyInformation)
  return false;
#undef DO_
}

void CdmKeyInformation::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmKeyInformation)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bytes key_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      1, this->key_id(), output);
  }

  // optional .media.remoting.pb.CdmKeyInformation.KeyStatus status = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->status(), output);
  }

  // optional uint32 system_code = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->system_code(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmKeyInformation)
}

size_t CdmKeyInformation::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmKeyInformation)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional bytes key_id = 1;
    if (has_key_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->key_id());
    }

    // optional .media.remoting.pb.CdmKeyInformation.KeyStatus status = 2;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
    }

    // optional uint32 system_code = 3;
    if (has_system_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->system_code());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmKeyInformation::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmKeyInformation*>(&from));
}

void CdmKeyInformation::MergeFrom(const CdmKeyInformation& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmKeyInformation)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_key_id();
      key_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      status_ = from.status_;
    }
    if (cached_has_bits & 0x00000004u) {
      system_code_ = from.system_code_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmKeyInformation::CopyFrom(const CdmKeyInformation& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmKeyInformation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmKeyInformation::IsInitialized() const {
  return true;
}

void CdmKeyInformation::Swap(CdmKeyInformation* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmKeyInformation::InternalSwap(CdmKeyInformation* other) {
  key_id_.Swap(&other->key_id_);
  std::swap(status_, other->status_);
  std::swap(system_code_, other->system_code_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmKeyInformation::GetTypeName() const {
  return "media.remoting.pb.CdmKeyInformation";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmKeyInformation

// optional bytes key_id = 1;
bool CdmKeyInformation::has_key_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmKeyInformation::set_has_key_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmKeyInformation::clear_has_key_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmKeyInformation::clear_key_id() {
  key_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key_id();
}
const ::std::string& CdmKeyInformation::key_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmKeyInformation.key_id)
  return key_id_.GetNoArena();
}
void CdmKeyInformation::set_key_id(const ::std::string& value) {
  set_has_key_id();
  key_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmKeyInformation.key_id)
}
#if LANG_CXX11
void CdmKeyInformation::set_key_id(::std::string&& value) {
  set_has_key_id();
  key_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmKeyInformation.key_id)
}
#endif
void CdmKeyInformation::set_key_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key_id();
  key_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmKeyInformation.key_id)
}
void CdmKeyInformation::set_key_id(const void* value, size_t size) {
  set_has_key_id();
  key_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmKeyInformation.key_id)
}
::std::string* CdmKeyInformation::mutable_key_id() {
  set_has_key_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmKeyInformation.key_id)
  return key_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmKeyInformation::release_key_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmKeyInformation.key_id)
  clear_has_key_id();
  return key_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmKeyInformation::set_allocated_key_id(::std::string* key_id) {
  if (key_id != NULL) {
    set_has_key_id();
  } else {
    clear_has_key_id();
  }
  key_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmKeyInformation.key_id)
}

// optional .media.remoting.pb.CdmKeyInformation.KeyStatus status = 2;
bool CdmKeyInformation::has_status() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmKeyInformation::set_has_status() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmKeyInformation::clear_has_status() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmKeyInformation::clear_status() {
  status_ = 0;
  clear_has_status();
}
::media::remoting::pb::CdmKeyInformation_KeyStatus CdmKeyInformation::status() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmKeyInformation.status)
  return static_cast< ::media::remoting::pb::CdmKeyInformation_KeyStatus >(status_);
}
void CdmKeyInformation::set_status(::media::remoting::pb::CdmKeyInformation_KeyStatus value) {
  assert(::media::remoting::pb::CdmKeyInformation_KeyStatus_IsValid(value));
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmKeyInformation.status)
}

// optional uint32 system_code = 3;
bool CdmKeyInformation::has_system_code() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmKeyInformation::set_has_system_code() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmKeyInformation::clear_has_system_code() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmKeyInformation::clear_system_code() {
  system_code_ = 0u;
  clear_has_system_code();
}
::google::protobuf::uint32 CdmKeyInformation::system_code() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmKeyInformation.system_code)
  return system_code_;
}
void CdmKeyInformation::set_system_code(::google::protobuf::uint32 value) {
  set_has_system_code();
  system_code_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmKeyInformation.system_code)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererInitialize::kClientHandleFieldNumber;
const int RendererInitialize::kAudioDemuxerHandleFieldNumber;
const int RendererInitialize::kVideoDemuxerHandleFieldNumber;
const int RendererInitialize::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererInitialize::RendererInitialize()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererInitialize)
}
RendererInitialize::RendererInitialize(const RendererInitialize& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&client_handle_, &from.client_handle_,
    static_cast<size_t>(reinterpret_cast<char*>(&callback_handle_) -
    reinterpret_cast<char*>(&client_handle_)) + sizeof(callback_handle_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererInitialize)
}

void RendererInitialize::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&client_handle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&callback_handle_) -
      reinterpret_cast<char*>(&client_handle_)) + sizeof(callback_handle_));
}

RendererInitialize::~RendererInitialize() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererInitialize)
  SharedDtor();
}

void RendererInitialize::SharedDtor() {
}

void RendererInitialize::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererInitialize& RendererInitialize::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererInitialize* RendererInitialize::New(::google::protobuf::Arena* arena) const {
  RendererInitialize* n = new RendererInitialize;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererInitialize::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererInitialize)
  if (_has_bits_[0 / 32] & 15u) {
    ::memset(&client_handle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&callback_handle_) -
        reinterpret_cast<char*>(&client_handle_)) + sizeof(callback_handle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererInitialize::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererInitialize)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 client_handle = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_client_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &client_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 audio_demuxer_handle = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_audio_demuxer_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &audio_demuxer_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 video_demuxer_handle = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_video_demuxer_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &video_demuxer_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererInitialize)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererInitialize)
  return false;
#undef DO_
}

void RendererInitialize::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererInitialize)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 client_handle = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->client_handle(), output);
  }

  // optional int32 audio_demuxer_handle = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->audio_demuxer_handle(), output);
  }

  // optional int32 video_demuxer_handle = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->video_demuxer_handle(), output);
  }

  // optional int32 callback_handle = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererInitialize)
}

size_t RendererInitialize::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererInitialize)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional int32 client_handle = 1;
    if (has_client_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->client_handle());
    }

    // optional int32 audio_demuxer_handle = 2;
    if (has_audio_demuxer_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->audio_demuxer_handle());
    }

    // optional int32 video_demuxer_handle = 3;
    if (has_video_demuxer_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->video_demuxer_handle());
    }

    // optional int32 callback_handle = 4;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererInitialize::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererInitialize*>(&from));
}

void RendererInitialize::MergeFrom(const RendererInitialize& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererInitialize)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      client_handle_ = from.client_handle_;
    }
    if (cached_has_bits & 0x00000002u) {
      audio_demuxer_handle_ = from.audio_demuxer_handle_;
    }
    if (cached_has_bits & 0x00000004u) {
      video_demuxer_handle_ = from.video_demuxer_handle_;
    }
    if (cached_has_bits & 0x00000008u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RendererInitialize::CopyFrom(const RendererInitialize& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererInitialize)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererInitialize::IsInitialized() const {
  return true;
}

void RendererInitialize::Swap(RendererInitialize* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererInitialize::InternalSwap(RendererInitialize* other) {
  std::swap(client_handle_, other->client_handle_);
  std::swap(audio_demuxer_handle_, other->audio_demuxer_handle_);
  std::swap(video_demuxer_handle_, other->video_demuxer_handle_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererInitialize::GetTypeName() const {
  return "media.remoting.pb.RendererInitialize";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererInitialize

// optional int32 client_handle = 1;
bool RendererInitialize::has_client_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererInitialize::set_has_client_handle() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererInitialize::clear_has_client_handle() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererInitialize::clear_client_handle() {
  client_handle_ = 0;
  clear_has_client_handle();
}
::google::protobuf::int32 RendererInitialize::client_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererInitialize.client_handle)
  return client_handle_;
}
void RendererInitialize::set_client_handle(::google::protobuf::int32 value) {
  set_has_client_handle();
  client_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererInitialize.client_handle)
}

// optional int32 audio_demuxer_handle = 2;
bool RendererInitialize::has_audio_demuxer_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RendererInitialize::set_has_audio_demuxer_handle() {
  _has_bits_[0] |= 0x00000002u;
}
void RendererInitialize::clear_has_audio_demuxer_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
void RendererInitialize::clear_audio_demuxer_handle() {
  audio_demuxer_handle_ = 0;
  clear_has_audio_demuxer_handle();
}
::google::protobuf::int32 RendererInitialize::audio_demuxer_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererInitialize.audio_demuxer_handle)
  return audio_demuxer_handle_;
}
void RendererInitialize::set_audio_demuxer_handle(::google::protobuf::int32 value) {
  set_has_audio_demuxer_handle();
  audio_demuxer_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererInitialize.audio_demuxer_handle)
}

// optional int32 video_demuxer_handle = 3;
bool RendererInitialize::has_video_demuxer_handle() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void RendererInitialize::set_has_video_demuxer_handle() {
  _has_bits_[0] |= 0x00000004u;
}
void RendererInitialize::clear_has_video_demuxer_handle() {
  _has_bits_[0] &= ~0x00000004u;
}
void RendererInitialize::clear_video_demuxer_handle() {
  video_demuxer_handle_ = 0;
  clear_has_video_demuxer_handle();
}
::google::protobuf::int32 RendererInitialize::video_demuxer_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererInitialize.video_demuxer_handle)
  return video_demuxer_handle_;
}
void RendererInitialize::set_video_demuxer_handle(::google::protobuf::int32 value) {
  set_has_video_demuxer_handle();
  video_demuxer_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererInitialize.video_demuxer_handle)
}

// optional int32 callback_handle = 4;
bool RendererInitialize::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void RendererInitialize::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000008u;
}
void RendererInitialize::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000008u;
}
void RendererInitialize::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 RendererInitialize::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererInitialize.callback_handle)
  return callback_handle_;
}
void RendererInitialize::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererInitialize.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererFlushUntil::kAudioCountFieldNumber;
const int RendererFlushUntil::kVideoCountFieldNumber;
const int RendererFlushUntil::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererFlushUntil::RendererFlushUntil()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererFlushUntil)
}
RendererFlushUntil::RendererFlushUntil(const RendererFlushUntil& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&audio_count_, &from.audio_count_,
    static_cast<size_t>(reinterpret_cast<char*>(&callback_handle_) -
    reinterpret_cast<char*>(&audio_count_)) + sizeof(callback_handle_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererFlushUntil)
}

void RendererFlushUntil::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&audio_count_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&callback_handle_) -
      reinterpret_cast<char*>(&audio_count_)) + sizeof(callback_handle_));
}

RendererFlushUntil::~RendererFlushUntil() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererFlushUntil)
  SharedDtor();
}

void RendererFlushUntil::SharedDtor() {
}

void RendererFlushUntil::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererFlushUntil& RendererFlushUntil::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererFlushUntil* RendererFlushUntil::New(::google::protobuf::Arena* arena) const {
  RendererFlushUntil* n = new RendererFlushUntil;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererFlushUntil::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererFlushUntil)
  if (_has_bits_[0 / 32] & 7u) {
    ::memset(&audio_count_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&callback_handle_) -
        reinterpret_cast<char*>(&audio_count_)) + sizeof(callback_handle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererFlushUntil::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererFlushUntil)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional uint32 audio_count = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_audio_count();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &audio_count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 video_count = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_video_count();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &video_count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererFlushUntil)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererFlushUntil)
  return false;
#undef DO_
}

void RendererFlushUntil::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererFlushUntil)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional uint32 audio_count = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->audio_count(), output);
  }

  // optional uint32 video_count = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->video_count(), output);
  }

  // optional int32 callback_handle = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererFlushUntil)
}

size_t RendererFlushUntil::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererFlushUntil)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional uint32 audio_count = 1;
    if (has_audio_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->audio_count());
    }

    // optional uint32 video_count = 2;
    if (has_video_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->video_count());
    }

    // optional int32 callback_handle = 3;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererFlushUntil::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererFlushUntil*>(&from));
}

void RendererFlushUntil::MergeFrom(const RendererFlushUntil& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererFlushUntil)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      audio_count_ = from.audio_count_;
    }
    if (cached_has_bits & 0x00000002u) {
      video_count_ = from.video_count_;
    }
    if (cached_has_bits & 0x00000004u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RendererFlushUntil::CopyFrom(const RendererFlushUntil& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererFlushUntil)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererFlushUntil::IsInitialized() const {
  return true;
}

void RendererFlushUntil::Swap(RendererFlushUntil* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererFlushUntil::InternalSwap(RendererFlushUntil* other) {
  std::swap(audio_count_, other->audio_count_);
  std::swap(video_count_, other->video_count_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererFlushUntil::GetTypeName() const {
  return "media.remoting.pb.RendererFlushUntil";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererFlushUntil

// optional uint32 audio_count = 1;
bool RendererFlushUntil::has_audio_count() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererFlushUntil::set_has_audio_count() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererFlushUntil::clear_has_audio_count() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererFlushUntil::clear_audio_count() {
  audio_count_ = 0u;
  clear_has_audio_count();
}
::google::protobuf::uint32 RendererFlushUntil::audio_count() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererFlushUntil.audio_count)
  return audio_count_;
}
void RendererFlushUntil::set_audio_count(::google::protobuf::uint32 value) {
  set_has_audio_count();
  audio_count_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererFlushUntil.audio_count)
}

// optional uint32 video_count = 2;
bool RendererFlushUntil::has_video_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RendererFlushUntil::set_has_video_count() {
  _has_bits_[0] |= 0x00000002u;
}
void RendererFlushUntil::clear_has_video_count() {
  _has_bits_[0] &= ~0x00000002u;
}
void RendererFlushUntil::clear_video_count() {
  video_count_ = 0u;
  clear_has_video_count();
}
::google::protobuf::uint32 RendererFlushUntil::video_count() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererFlushUntil.video_count)
  return video_count_;
}
void RendererFlushUntil::set_video_count(::google::protobuf::uint32 value) {
  set_has_video_count();
  video_count_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererFlushUntil.video_count)
}

// optional int32 callback_handle = 3;
bool RendererFlushUntil::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void RendererFlushUntil::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000004u;
}
void RendererFlushUntil::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000004u;
}
void RendererFlushUntil::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 RendererFlushUntil::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererFlushUntil.callback_handle)
  return callback_handle_;
}
void RendererFlushUntil::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererFlushUntil.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererSetCdm::kCdmIdFieldNumber;
const int RendererSetCdm::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererSetCdm::RendererSetCdm()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererSetCdm)
}
RendererSetCdm::RendererSetCdm(const RendererSetCdm& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&cdm_id_, &from.cdm_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&callback_handle_) -
    reinterpret_cast<char*>(&cdm_id_)) + sizeof(callback_handle_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererSetCdm)
}

void RendererSetCdm::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&cdm_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&callback_handle_) -
      reinterpret_cast<char*>(&cdm_id_)) + sizeof(callback_handle_));
}

RendererSetCdm::~RendererSetCdm() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererSetCdm)
  SharedDtor();
}

void RendererSetCdm::SharedDtor() {
}

void RendererSetCdm::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererSetCdm& RendererSetCdm::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererSetCdm* RendererSetCdm::New(::google::protobuf::Arena* arena) const {
  RendererSetCdm* n = new RendererSetCdm;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererSetCdm::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererSetCdm)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&cdm_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&callback_handle_) -
        reinterpret_cast<char*>(&cdm_id_)) + sizeof(callback_handle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererSetCdm::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererSetCdm)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 cdm_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_cdm_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &cdm_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererSetCdm)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererSetCdm)
  return false;
#undef DO_
}

void RendererSetCdm::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererSetCdm)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 cdm_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->cdm_id(), output);
  }

  // optional int32 callback_handle = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererSetCdm)
}

size_t RendererSetCdm::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererSetCdm)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 cdm_id = 1;
    if (has_cdm_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->cdm_id());
    }

    // optional int32 callback_handle = 2;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererSetCdm::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererSetCdm*>(&from));
}

void RendererSetCdm::MergeFrom(const RendererSetCdm& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererSetCdm)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      cdm_id_ = from.cdm_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RendererSetCdm::CopyFrom(const RendererSetCdm& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererSetCdm)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererSetCdm::IsInitialized() const {
  return true;
}

void RendererSetCdm::Swap(RendererSetCdm* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererSetCdm::InternalSwap(RendererSetCdm* other) {
  std::swap(cdm_id_, other->cdm_id_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererSetCdm::GetTypeName() const {
  return "media.remoting.pb.RendererSetCdm";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererSetCdm

// optional int32 cdm_id = 1;
bool RendererSetCdm::has_cdm_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererSetCdm::set_has_cdm_id() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererSetCdm::clear_has_cdm_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererSetCdm::clear_cdm_id() {
  cdm_id_ = 0;
  clear_has_cdm_id();
}
::google::protobuf::int32 RendererSetCdm::cdm_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererSetCdm.cdm_id)
  return cdm_id_;
}
void RendererSetCdm::set_cdm_id(::google::protobuf::int32 value) {
  set_has_cdm_id();
  cdm_id_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererSetCdm.cdm_id)
}

// optional int32 callback_handle = 2;
bool RendererSetCdm::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RendererSetCdm::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000002u;
}
void RendererSetCdm::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
void RendererSetCdm::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 RendererSetCdm::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererSetCdm.callback_handle)
  return callback_handle_;
}
void RendererSetCdm::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererSetCdm.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererClientOnTimeUpdate::kTimeUsecFieldNumber;
const int RendererClientOnTimeUpdate::kMaxTimeUsecFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererClientOnTimeUpdate::RendererClientOnTimeUpdate()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererClientOnTimeUpdate)
}
RendererClientOnTimeUpdate::RendererClientOnTimeUpdate(const RendererClientOnTimeUpdate& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&time_usec_, &from.time_usec_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_time_usec_) -
    reinterpret_cast<char*>(&time_usec_)) + sizeof(max_time_usec_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererClientOnTimeUpdate)
}

void RendererClientOnTimeUpdate::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&time_usec_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&max_time_usec_) -
      reinterpret_cast<char*>(&time_usec_)) + sizeof(max_time_usec_));
}

RendererClientOnTimeUpdate::~RendererClientOnTimeUpdate() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererClientOnTimeUpdate)
  SharedDtor();
}

void RendererClientOnTimeUpdate::SharedDtor() {
}

void RendererClientOnTimeUpdate::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererClientOnTimeUpdate& RendererClientOnTimeUpdate::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererClientOnTimeUpdate* RendererClientOnTimeUpdate::New(::google::protobuf::Arena* arena) const {
  RendererClientOnTimeUpdate* n = new RendererClientOnTimeUpdate;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererClientOnTimeUpdate::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererClientOnTimeUpdate)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&time_usec_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&max_time_usec_) -
        reinterpret_cast<char*>(&time_usec_)) + sizeof(max_time_usec_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererClientOnTimeUpdate::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererClientOnTimeUpdate)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int64 time_usec = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_time_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &time_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 max_time_usec = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_max_time_usec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &max_time_usec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererClientOnTimeUpdate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererClientOnTimeUpdate)
  return false;
#undef DO_
}

void RendererClientOnTimeUpdate::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererClientOnTimeUpdate)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int64 time_usec = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->time_usec(), output);
  }

  // optional int64 max_time_usec = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->max_time_usec(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererClientOnTimeUpdate)
}

size_t RendererClientOnTimeUpdate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererClientOnTimeUpdate)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int64 time_usec = 1;
    if (has_time_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->time_usec());
    }

    // optional int64 max_time_usec = 2;
    if (has_max_time_usec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->max_time_usec());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererClientOnTimeUpdate::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererClientOnTimeUpdate*>(&from));
}

void RendererClientOnTimeUpdate::MergeFrom(const RendererClientOnTimeUpdate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererClientOnTimeUpdate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      time_usec_ = from.time_usec_;
    }
    if (cached_has_bits & 0x00000002u) {
      max_time_usec_ = from.max_time_usec_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RendererClientOnTimeUpdate::CopyFrom(const RendererClientOnTimeUpdate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererClientOnTimeUpdate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererClientOnTimeUpdate::IsInitialized() const {
  return true;
}

void RendererClientOnTimeUpdate::Swap(RendererClientOnTimeUpdate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererClientOnTimeUpdate::InternalSwap(RendererClientOnTimeUpdate* other) {
  std::swap(time_usec_, other->time_usec_);
  std::swap(max_time_usec_, other->max_time_usec_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererClientOnTimeUpdate::GetTypeName() const {
  return "media.remoting.pb.RendererClientOnTimeUpdate";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererClientOnTimeUpdate

// optional int64 time_usec = 1;
bool RendererClientOnTimeUpdate::has_time_usec() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererClientOnTimeUpdate::set_has_time_usec() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererClientOnTimeUpdate::clear_has_time_usec() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererClientOnTimeUpdate::clear_time_usec() {
  time_usec_ = GOOGLE_LONGLONG(0);
  clear_has_time_usec();
}
::google::protobuf::int64 RendererClientOnTimeUpdate::time_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererClientOnTimeUpdate.time_usec)
  return time_usec_;
}
void RendererClientOnTimeUpdate::set_time_usec(::google::protobuf::int64 value) {
  set_has_time_usec();
  time_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererClientOnTimeUpdate.time_usec)
}

// optional int64 max_time_usec = 2;
bool RendererClientOnTimeUpdate::has_max_time_usec() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RendererClientOnTimeUpdate::set_has_max_time_usec() {
  _has_bits_[0] |= 0x00000002u;
}
void RendererClientOnTimeUpdate::clear_has_max_time_usec() {
  _has_bits_[0] &= ~0x00000002u;
}
void RendererClientOnTimeUpdate::clear_max_time_usec() {
  max_time_usec_ = GOOGLE_LONGLONG(0);
  clear_has_max_time_usec();
}
::google::protobuf::int64 RendererClientOnTimeUpdate::max_time_usec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererClientOnTimeUpdate.max_time_usec)
  return max_time_usec_;
}
void RendererClientOnTimeUpdate::set_max_time_usec(::google::protobuf::int64 value) {
  set_has_max_time_usec();
  max_time_usec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererClientOnTimeUpdate.max_time_usec)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererClientOnBufferingStateChange::kStateFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererClientOnBufferingStateChange::RendererClientOnBufferingStateChange()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererClientOnBufferingStateChange)
}
RendererClientOnBufferingStateChange::RendererClientOnBufferingStateChange(const RendererClientOnBufferingStateChange& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  state_ = from.state_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererClientOnBufferingStateChange)
}

void RendererClientOnBufferingStateChange::SharedCtor() {
  _cached_size_ = 0;
  state_ = 0;
}

RendererClientOnBufferingStateChange::~RendererClientOnBufferingStateChange() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererClientOnBufferingStateChange)
  SharedDtor();
}

void RendererClientOnBufferingStateChange::SharedDtor() {
}

void RendererClientOnBufferingStateChange::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererClientOnBufferingStateChange& RendererClientOnBufferingStateChange::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererClientOnBufferingStateChange* RendererClientOnBufferingStateChange::New(::google::protobuf::Arena* arena) const {
  RendererClientOnBufferingStateChange* n = new RendererClientOnBufferingStateChange;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererClientOnBufferingStateChange::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererClientOnBufferingStateChange)
  state_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererClientOnBufferingStateChange::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererClientOnBufferingStateChange)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.RendererClientOnBufferingStateChange.State state = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::RendererClientOnBufferingStateChange_State_IsValid(value)) {
            set_state(static_cast< ::media::remoting::pb::RendererClientOnBufferingStateChange_State >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererClientOnBufferingStateChange)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererClientOnBufferingStateChange)
  return false;
#undef DO_
}

void RendererClientOnBufferingStateChange::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererClientOnBufferingStateChange)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.RendererClientOnBufferingStateChange.State state = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->state(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererClientOnBufferingStateChange)
}

size_t RendererClientOnBufferingStateChange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererClientOnBufferingStateChange)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional .media.remoting.pb.RendererClientOnBufferingStateChange.State state = 1;
  if (has_state()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->state());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererClientOnBufferingStateChange::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererClientOnBufferingStateChange*>(&from));
}

void RendererClientOnBufferingStateChange::MergeFrom(const RendererClientOnBufferingStateChange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererClientOnBufferingStateChange)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_state()) {
    set_state(from.state());
  }
}

void RendererClientOnBufferingStateChange::CopyFrom(const RendererClientOnBufferingStateChange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererClientOnBufferingStateChange)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererClientOnBufferingStateChange::IsInitialized() const {
  return true;
}

void RendererClientOnBufferingStateChange::Swap(RendererClientOnBufferingStateChange* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererClientOnBufferingStateChange::InternalSwap(RendererClientOnBufferingStateChange* other) {
  std::swap(state_, other->state_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererClientOnBufferingStateChange::GetTypeName() const {
  return "media.remoting.pb.RendererClientOnBufferingStateChange";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererClientOnBufferingStateChange

// optional .media.remoting.pb.RendererClientOnBufferingStateChange.State state = 1;
bool RendererClientOnBufferingStateChange::has_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererClientOnBufferingStateChange::set_has_state() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererClientOnBufferingStateChange::clear_has_state() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererClientOnBufferingStateChange::clear_state() {
  state_ = 0;
  clear_has_state();
}
::media::remoting::pb::RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::state() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererClientOnBufferingStateChange.state)
  return static_cast< ::media::remoting::pb::RendererClientOnBufferingStateChange_State >(state_);
}
void RendererClientOnBufferingStateChange::set_state(::media::remoting::pb::RendererClientOnBufferingStateChange_State value) {
  assert(::media::remoting::pb::RendererClientOnBufferingStateChange_State_IsValid(value));
  set_has_state();
  state_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RendererClientOnBufferingStateChange.state)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererClientOnAudioConfigChange::kAudioDecoderConfigFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererClientOnAudioConfigChange::RendererClientOnAudioConfigChange()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererClientOnAudioConfigChange)
}
RendererClientOnAudioConfigChange::RendererClientOnAudioConfigChange(const RendererClientOnAudioConfigChange& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_audio_decoder_config()) {
    audio_decoder_config_ = new ::media::remoting::pb::AudioDecoderConfig(*from.audio_decoder_config_);
  } else {
    audio_decoder_config_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererClientOnAudioConfigChange)
}

void RendererClientOnAudioConfigChange::SharedCtor() {
  _cached_size_ = 0;
  audio_decoder_config_ = NULL;
}

RendererClientOnAudioConfigChange::~RendererClientOnAudioConfigChange() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererClientOnAudioConfigChange)
  SharedDtor();
}

void RendererClientOnAudioConfigChange::SharedDtor() {
  if (this != internal_default_instance()) {
    delete audio_decoder_config_;
  }
}

void RendererClientOnAudioConfigChange::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererClientOnAudioConfigChange& RendererClientOnAudioConfigChange::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererClientOnAudioConfigChange* RendererClientOnAudioConfigChange::New(::google::protobuf::Arena* arena) const {
  RendererClientOnAudioConfigChange* n = new RendererClientOnAudioConfigChange;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererClientOnAudioConfigChange::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererClientOnAudioConfigChange)
  if (has_audio_decoder_config()) {
    GOOGLE_DCHECK(audio_decoder_config_ != NULL);
    audio_decoder_config_->::media::remoting::pb::AudioDecoderConfig::Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererClientOnAudioConfigChange::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererClientOnAudioConfigChange)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_audio_decoder_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererClientOnAudioConfigChange)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererClientOnAudioConfigChange)
  return false;
#undef DO_
}

void RendererClientOnAudioConfigChange::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererClientOnAudioConfigChange)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->audio_decoder_config_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererClientOnAudioConfigChange)
}

size_t RendererClientOnAudioConfigChange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererClientOnAudioConfigChange)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 1;
  if (has_audio_decoder_config()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->audio_decoder_config_);
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererClientOnAudioConfigChange::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererClientOnAudioConfigChange*>(&from));
}

void RendererClientOnAudioConfigChange::MergeFrom(const RendererClientOnAudioConfigChange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererClientOnAudioConfigChange)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_audio_decoder_config()) {
    mutable_audio_decoder_config()->::media::remoting::pb::AudioDecoderConfig::MergeFrom(from.audio_decoder_config());
  }
}

void RendererClientOnAudioConfigChange::CopyFrom(const RendererClientOnAudioConfigChange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererClientOnAudioConfigChange)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererClientOnAudioConfigChange::IsInitialized() const {
  return true;
}

void RendererClientOnAudioConfigChange::Swap(RendererClientOnAudioConfigChange* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererClientOnAudioConfigChange::InternalSwap(RendererClientOnAudioConfigChange* other) {
  std::swap(audio_decoder_config_, other->audio_decoder_config_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererClientOnAudioConfigChange::GetTypeName() const {
  return "media.remoting.pb.RendererClientOnAudioConfigChange";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererClientOnAudioConfigChange

// optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 1;
bool RendererClientOnAudioConfigChange::has_audio_decoder_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererClientOnAudioConfigChange::set_has_audio_decoder_config() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererClientOnAudioConfigChange::clear_has_audio_decoder_config() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererClientOnAudioConfigChange::clear_audio_decoder_config() {
  if (audio_decoder_config_ != NULL) audio_decoder_config_->::media::remoting::pb::AudioDecoderConfig::Clear();
  clear_has_audio_decoder_config();
}
const ::media::remoting::pb::AudioDecoderConfig& RendererClientOnAudioConfigChange::audio_decoder_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererClientOnAudioConfigChange.audio_decoder_config)
  return audio_decoder_config_ != NULL ? *audio_decoder_config_
                         : *::media::remoting::pb::AudioDecoderConfig::internal_default_instance();
}
::media::remoting::pb::AudioDecoderConfig* RendererClientOnAudioConfigChange::mutable_audio_decoder_config() {
  set_has_audio_decoder_config();
  if (audio_decoder_config_ == NULL) {
    audio_decoder_config_ = new ::media::remoting::pb::AudioDecoderConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RendererClientOnAudioConfigChange.audio_decoder_config)
  return audio_decoder_config_;
}
::media::remoting::pb::AudioDecoderConfig* RendererClientOnAudioConfigChange::release_audio_decoder_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RendererClientOnAudioConfigChange.audio_decoder_config)
  clear_has_audio_decoder_config();
  ::media::remoting::pb::AudioDecoderConfig* temp = audio_decoder_config_;
  audio_decoder_config_ = NULL;
  return temp;
}
void RendererClientOnAudioConfigChange::set_allocated_audio_decoder_config(::media::remoting::pb::AudioDecoderConfig* audio_decoder_config) {
  delete audio_decoder_config_;
  audio_decoder_config_ = audio_decoder_config;
  if (audio_decoder_config) {
    set_has_audio_decoder_config();
  } else {
    clear_has_audio_decoder_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RendererClientOnAudioConfigChange.audio_decoder_config)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RendererClientOnVideoConfigChange::kVideoDecoderConfigFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RendererClientOnVideoConfigChange::RendererClientOnVideoConfigChange()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RendererClientOnVideoConfigChange)
}
RendererClientOnVideoConfigChange::RendererClientOnVideoConfigChange(const RendererClientOnVideoConfigChange& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_video_decoder_config()) {
    video_decoder_config_ = new ::media::remoting::pb::VideoDecoderConfig(*from.video_decoder_config_);
  } else {
    video_decoder_config_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RendererClientOnVideoConfigChange)
}

void RendererClientOnVideoConfigChange::SharedCtor() {
  _cached_size_ = 0;
  video_decoder_config_ = NULL;
}

RendererClientOnVideoConfigChange::~RendererClientOnVideoConfigChange() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RendererClientOnVideoConfigChange)
  SharedDtor();
}

void RendererClientOnVideoConfigChange::SharedDtor() {
  if (this != internal_default_instance()) {
    delete video_decoder_config_;
  }
}

void RendererClientOnVideoConfigChange::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RendererClientOnVideoConfigChange& RendererClientOnVideoConfigChange::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RendererClientOnVideoConfigChange* RendererClientOnVideoConfigChange::New(::google::protobuf::Arena* arena) const {
  RendererClientOnVideoConfigChange* n = new RendererClientOnVideoConfigChange;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RendererClientOnVideoConfigChange::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RendererClientOnVideoConfigChange)
  if (has_video_decoder_config()) {
    GOOGLE_DCHECK(video_decoder_config_ != NULL);
    video_decoder_config_->::media::remoting::pb::VideoDecoderConfig::Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RendererClientOnVideoConfigChange::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RendererClientOnVideoConfigChange)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_video_decoder_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RendererClientOnVideoConfigChange)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RendererClientOnVideoConfigChange)
  return false;
#undef DO_
}

void RendererClientOnVideoConfigChange::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RendererClientOnVideoConfigChange)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->video_decoder_config_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RendererClientOnVideoConfigChange)
}

size_t RendererClientOnVideoConfigChange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RendererClientOnVideoConfigChange)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 1;
  if (has_video_decoder_config()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->video_decoder_config_);
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RendererClientOnVideoConfigChange::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RendererClientOnVideoConfigChange*>(&from));
}

void RendererClientOnVideoConfigChange::MergeFrom(const RendererClientOnVideoConfigChange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RendererClientOnVideoConfigChange)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_video_decoder_config()) {
    mutable_video_decoder_config()->::media::remoting::pb::VideoDecoderConfig::MergeFrom(from.video_decoder_config());
  }
}

void RendererClientOnVideoConfigChange::CopyFrom(const RendererClientOnVideoConfigChange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RendererClientOnVideoConfigChange)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RendererClientOnVideoConfigChange::IsInitialized() const {
  return true;
}

void RendererClientOnVideoConfigChange::Swap(RendererClientOnVideoConfigChange* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RendererClientOnVideoConfigChange::InternalSwap(RendererClientOnVideoConfigChange* other) {
  std::swap(video_decoder_config_, other->video_decoder_config_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RendererClientOnVideoConfigChange::GetTypeName() const {
  return "media.remoting.pb.RendererClientOnVideoConfigChange";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RendererClientOnVideoConfigChange

// optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 1;
bool RendererClientOnVideoConfigChange::has_video_decoder_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RendererClientOnVideoConfigChange::set_has_video_decoder_config() {
  _has_bits_[0] |= 0x00000001u;
}
void RendererClientOnVideoConfigChange::clear_has_video_decoder_config() {
  _has_bits_[0] &= ~0x00000001u;
}
void RendererClientOnVideoConfigChange::clear_video_decoder_config() {
  if (video_decoder_config_ != NULL) video_decoder_config_->::media::remoting::pb::VideoDecoderConfig::Clear();
  clear_has_video_decoder_config();
}
const ::media::remoting::pb::VideoDecoderConfig& RendererClientOnVideoConfigChange::video_decoder_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RendererClientOnVideoConfigChange.video_decoder_config)
  return video_decoder_config_ != NULL ? *video_decoder_config_
                         : *::media::remoting::pb::VideoDecoderConfig::internal_default_instance();
}
::media::remoting::pb::VideoDecoderConfig* RendererClientOnVideoConfigChange::mutable_video_decoder_config() {
  set_has_video_decoder_config();
  if (video_decoder_config_ == NULL) {
    video_decoder_config_ = new ::media::remoting::pb::VideoDecoderConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RendererClientOnVideoConfigChange.video_decoder_config)
  return video_decoder_config_;
}
::media::remoting::pb::VideoDecoderConfig* RendererClientOnVideoConfigChange::release_video_decoder_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RendererClientOnVideoConfigChange.video_decoder_config)
  clear_has_video_decoder_config();
  ::media::remoting::pb::VideoDecoderConfig* temp = video_decoder_config_;
  video_decoder_config_ = NULL;
  return temp;
}
void RendererClientOnVideoConfigChange::set_allocated_video_decoder_config(::media::remoting::pb::VideoDecoderConfig* video_decoder_config) {
  delete video_decoder_config_;
  video_decoder_config_ = video_decoder_config;
  if (video_decoder_config) {
    set_has_video_decoder_config();
  } else {
    clear_has_video_decoder_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RendererClientOnVideoConfigChange.video_decoder_config)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DemuxerStreamReadUntil::kCallbackHandleFieldNumber;
const int DemuxerStreamReadUntil::kCountFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DemuxerStreamReadUntil::DemuxerStreamReadUntil()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.DemuxerStreamReadUntil)
}
DemuxerStreamReadUntil::DemuxerStreamReadUntil(const DemuxerStreamReadUntil& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&callback_handle_, &from.callback_handle_,
    static_cast<size_t>(reinterpret_cast<char*>(&count_) -
    reinterpret_cast<char*>(&callback_handle_)) + sizeof(count_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.DemuxerStreamReadUntil)
}

void DemuxerStreamReadUntil::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&callback_handle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&count_) -
      reinterpret_cast<char*>(&callback_handle_)) + sizeof(count_));
}

DemuxerStreamReadUntil::~DemuxerStreamReadUntil() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.DemuxerStreamReadUntil)
  SharedDtor();
}

void DemuxerStreamReadUntil::SharedDtor() {
}

void DemuxerStreamReadUntil::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DemuxerStreamReadUntil& DemuxerStreamReadUntil::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

DemuxerStreamReadUntil* DemuxerStreamReadUntil::New(::google::protobuf::Arena* arena) const {
  DemuxerStreamReadUntil* n = new DemuxerStreamReadUntil;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DemuxerStreamReadUntil::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.DemuxerStreamReadUntil)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&callback_handle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&count_) -
        reinterpret_cast<char*>(&callback_handle_)) + sizeof(count_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DemuxerStreamReadUntil::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.DemuxerStreamReadUntil)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 callback_handle = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 count = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_count();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.DemuxerStreamReadUntil)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.DemuxerStreamReadUntil)
  return false;
#undef DO_
}

void DemuxerStreamReadUntil::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.DemuxerStreamReadUntil)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 callback_handle = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->callback_handle(), output);
  }

  // optional uint32 count = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->count(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.DemuxerStreamReadUntil)
}

size_t DemuxerStreamReadUntil::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.DemuxerStreamReadUntil)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 callback_handle = 1;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

    // optional uint32 count = 2;
    if (has_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->count());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DemuxerStreamReadUntil::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DemuxerStreamReadUntil*>(&from));
}

void DemuxerStreamReadUntil::MergeFrom(const DemuxerStreamReadUntil& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.DemuxerStreamReadUntil)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      callback_handle_ = from.callback_handle_;
    }
    if (cached_has_bits & 0x00000002u) {
      count_ = from.count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DemuxerStreamReadUntil::CopyFrom(const DemuxerStreamReadUntil& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.DemuxerStreamReadUntil)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DemuxerStreamReadUntil::IsInitialized() const {
  return true;
}

void DemuxerStreamReadUntil::Swap(DemuxerStreamReadUntil* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DemuxerStreamReadUntil::InternalSwap(DemuxerStreamReadUntil* other) {
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(count_, other->count_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DemuxerStreamReadUntil::GetTypeName() const {
  return "media.remoting.pb.DemuxerStreamReadUntil";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DemuxerStreamReadUntil

// optional int32 callback_handle = 1;
bool DemuxerStreamReadUntil::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DemuxerStreamReadUntil::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000001u;
}
void DemuxerStreamReadUntil::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000001u;
}
void DemuxerStreamReadUntil::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 DemuxerStreamReadUntil::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamReadUntil.callback_handle)
  return callback_handle_;
}
void DemuxerStreamReadUntil::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DemuxerStreamReadUntil.callback_handle)
}

// optional uint32 count = 2;
bool DemuxerStreamReadUntil::has_count() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DemuxerStreamReadUntil::set_has_count() {
  _has_bits_[0] |= 0x00000002u;
}
void DemuxerStreamReadUntil::clear_has_count() {
  _has_bits_[0] &= ~0x00000002u;
}
void DemuxerStreamReadUntil::clear_count() {
  count_ = 0u;
  clear_has_count();
}
::google::protobuf::uint32 DemuxerStreamReadUntil::count() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamReadUntil.count)
  return count_;
}
void DemuxerStreamReadUntil::set_count(::google::protobuf::uint32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DemuxerStreamReadUntil.count)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DemuxerStreamInitializeCallback::kTypeFieldNumber;
const int DemuxerStreamInitializeCallback::kAudioDecoderConfigFieldNumber;
const int DemuxerStreamInitializeCallback::kVideoDecoderConfigFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DemuxerStreamInitializeCallback::DemuxerStreamInitializeCallback()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.DemuxerStreamInitializeCallback)
}
DemuxerStreamInitializeCallback::DemuxerStreamInitializeCallback(const DemuxerStreamInitializeCallback& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_audio_decoder_config()) {
    audio_decoder_config_ = new ::media::remoting::pb::AudioDecoderConfig(*from.audio_decoder_config_);
  } else {
    audio_decoder_config_ = NULL;
  }
  if (from.has_video_decoder_config()) {
    video_decoder_config_ = new ::media::remoting::pb::VideoDecoderConfig(*from.video_decoder_config_);
  } else {
    video_decoder_config_ = NULL;
  }
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.DemuxerStreamInitializeCallback)
}

void DemuxerStreamInitializeCallback::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&audio_decoder_config_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&type_) -
      reinterpret_cast<char*>(&audio_decoder_config_)) + sizeof(type_));
}

DemuxerStreamInitializeCallback::~DemuxerStreamInitializeCallback() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.DemuxerStreamInitializeCallback)
  SharedDtor();
}

void DemuxerStreamInitializeCallback::SharedDtor() {
  if (this != internal_default_instance()) {
    delete audio_decoder_config_;
  }
  if (this != internal_default_instance()) {
    delete video_decoder_config_;
  }
}

void DemuxerStreamInitializeCallback::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DemuxerStreamInitializeCallback& DemuxerStreamInitializeCallback::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

DemuxerStreamInitializeCallback* DemuxerStreamInitializeCallback::New(::google::protobuf::Arena* arena) const {
  DemuxerStreamInitializeCallback* n = new DemuxerStreamInitializeCallback;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DemuxerStreamInitializeCallback::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.DemuxerStreamInitializeCallback)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_audio_decoder_config()) {
      GOOGLE_DCHECK(audio_decoder_config_ != NULL);
      audio_decoder_config_->::media::remoting::pb::AudioDecoderConfig::Clear();
    }
    if (has_video_decoder_config()) {
      GOOGLE_DCHECK(video_decoder_config_ != NULL);
      video_decoder_config_->::media::remoting::pb::VideoDecoderConfig::Clear();
    }
  }
  type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DemuxerStreamInitializeCallback::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.DemuxerStreamInitializeCallback)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_type();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_audio_decoder_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_video_decoder_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.DemuxerStreamInitializeCallback)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.DemuxerStreamInitializeCallback)
  return false;
#undef DO_
}

void DemuxerStreamInitializeCallback::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.DemuxerStreamInitializeCallback)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 type = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->type(), output);
  }

  // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->audio_decoder_config_, output);
  }

  // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, *this->video_decoder_config_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.DemuxerStreamInitializeCallback)
}

size_t DemuxerStreamInitializeCallback::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.DemuxerStreamInitializeCallback)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 2;
    if (has_audio_decoder_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->audio_decoder_config_);
    }

    // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 3;
    if (has_video_decoder_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->video_decoder_config_);
    }

    // optional int32 type = 1;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->type());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DemuxerStreamInitializeCallback::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DemuxerStreamInitializeCallback*>(&from));
}

void DemuxerStreamInitializeCallback::MergeFrom(const DemuxerStreamInitializeCallback& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.DemuxerStreamInitializeCallback)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_audio_decoder_config()->::media::remoting::pb::AudioDecoderConfig::MergeFrom(from.audio_decoder_config());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_video_decoder_config()->::media::remoting::pb::VideoDecoderConfig::MergeFrom(from.video_decoder_config());
    }
    if (cached_has_bits & 0x00000004u) {
      type_ = from.type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DemuxerStreamInitializeCallback::CopyFrom(const DemuxerStreamInitializeCallback& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.DemuxerStreamInitializeCallback)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DemuxerStreamInitializeCallback::IsInitialized() const {
  return true;
}

void DemuxerStreamInitializeCallback::Swap(DemuxerStreamInitializeCallback* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DemuxerStreamInitializeCallback::InternalSwap(DemuxerStreamInitializeCallback* other) {
  std::swap(audio_decoder_config_, other->audio_decoder_config_);
  std::swap(video_decoder_config_, other->video_decoder_config_);
  std::swap(type_, other->type_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DemuxerStreamInitializeCallback::GetTypeName() const {
  return "media.remoting.pb.DemuxerStreamInitializeCallback";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DemuxerStreamInitializeCallback

// optional int32 type = 1;
bool DemuxerStreamInitializeCallback::has_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void DemuxerStreamInitializeCallback::set_has_type() {
  _has_bits_[0] |= 0x00000004u;
}
void DemuxerStreamInitializeCallback::clear_has_type() {
  _has_bits_[0] &= ~0x00000004u;
}
void DemuxerStreamInitializeCallback::clear_type() {
  type_ = 0;
  clear_has_type();
}
::google::protobuf::int32 DemuxerStreamInitializeCallback::type() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamInitializeCallback.type)
  return type_;
}
void DemuxerStreamInitializeCallback::set_type(::google::protobuf::int32 value) {
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DemuxerStreamInitializeCallback.type)
}

// optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 2;
bool DemuxerStreamInitializeCallback::has_audio_decoder_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DemuxerStreamInitializeCallback::set_has_audio_decoder_config() {
  _has_bits_[0] |= 0x00000001u;
}
void DemuxerStreamInitializeCallback::clear_has_audio_decoder_config() {
  _has_bits_[0] &= ~0x00000001u;
}
void DemuxerStreamInitializeCallback::clear_audio_decoder_config() {
  if (audio_decoder_config_ != NULL) audio_decoder_config_->::media::remoting::pb::AudioDecoderConfig::Clear();
  clear_has_audio_decoder_config();
}
const ::media::remoting::pb::AudioDecoderConfig& DemuxerStreamInitializeCallback::audio_decoder_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamInitializeCallback.audio_decoder_config)
  return audio_decoder_config_ != NULL ? *audio_decoder_config_
                         : *::media::remoting::pb::AudioDecoderConfig::internal_default_instance();
}
::media::remoting::pb::AudioDecoderConfig* DemuxerStreamInitializeCallback::mutable_audio_decoder_config() {
  set_has_audio_decoder_config();
  if (audio_decoder_config_ == NULL) {
    audio_decoder_config_ = new ::media::remoting::pb::AudioDecoderConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DemuxerStreamInitializeCallback.audio_decoder_config)
  return audio_decoder_config_;
}
::media::remoting::pb::AudioDecoderConfig* DemuxerStreamInitializeCallback::release_audio_decoder_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DemuxerStreamInitializeCallback.audio_decoder_config)
  clear_has_audio_decoder_config();
  ::media::remoting::pb::AudioDecoderConfig* temp = audio_decoder_config_;
  audio_decoder_config_ = NULL;
  return temp;
}
void DemuxerStreamInitializeCallback::set_allocated_audio_decoder_config(::media::remoting::pb::AudioDecoderConfig* audio_decoder_config) {
  delete audio_decoder_config_;
  audio_decoder_config_ = audio_decoder_config;
  if (audio_decoder_config) {
    set_has_audio_decoder_config();
  } else {
    clear_has_audio_decoder_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DemuxerStreamInitializeCallback.audio_decoder_config)
}

// optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 3;
bool DemuxerStreamInitializeCallback::has_video_decoder_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DemuxerStreamInitializeCallback::set_has_video_decoder_config() {
  _has_bits_[0] |= 0x00000002u;
}
void DemuxerStreamInitializeCallback::clear_has_video_decoder_config() {
  _has_bits_[0] &= ~0x00000002u;
}
void DemuxerStreamInitializeCallback::clear_video_decoder_config() {
  if (video_decoder_config_ != NULL) video_decoder_config_->::media::remoting::pb::VideoDecoderConfig::Clear();
  clear_has_video_decoder_config();
}
const ::media::remoting::pb::VideoDecoderConfig& DemuxerStreamInitializeCallback::video_decoder_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamInitializeCallback.video_decoder_config)
  return video_decoder_config_ != NULL ? *video_decoder_config_
                         : *::media::remoting::pb::VideoDecoderConfig::internal_default_instance();
}
::media::remoting::pb::VideoDecoderConfig* DemuxerStreamInitializeCallback::mutable_video_decoder_config() {
  set_has_video_decoder_config();
  if (video_decoder_config_ == NULL) {
    video_decoder_config_ = new ::media::remoting::pb::VideoDecoderConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DemuxerStreamInitializeCallback.video_decoder_config)
  return video_decoder_config_;
}
::media::remoting::pb::VideoDecoderConfig* DemuxerStreamInitializeCallback::release_video_decoder_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DemuxerStreamInitializeCallback.video_decoder_config)
  clear_has_video_decoder_config();
  ::media::remoting::pb::VideoDecoderConfig* temp = video_decoder_config_;
  video_decoder_config_ = NULL;
  return temp;
}
void DemuxerStreamInitializeCallback::set_allocated_video_decoder_config(::media::remoting::pb::VideoDecoderConfig* video_decoder_config) {
  delete video_decoder_config_;
  video_decoder_config_ = video_decoder_config;
  if (video_decoder_config) {
    set_has_video_decoder_config();
  } else {
    clear_has_video_decoder_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DemuxerStreamInitializeCallback.video_decoder_config)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DemuxerStreamReadUntilCallback::kStatusFieldNumber;
const int DemuxerStreamReadUntilCallback::kCountFieldNumber;
const int DemuxerStreamReadUntilCallback::kAudioDecoderConfigFieldNumber;
const int DemuxerStreamReadUntilCallback::kVideoDecoderConfigFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DemuxerStreamReadUntilCallback::DemuxerStreamReadUntilCallback()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.DemuxerStreamReadUntilCallback)
}
DemuxerStreamReadUntilCallback::DemuxerStreamReadUntilCallback(const DemuxerStreamReadUntilCallback& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_audio_decoder_config()) {
    audio_decoder_config_ = new ::media::remoting::pb::AudioDecoderConfig(*from.audio_decoder_config_);
  } else {
    audio_decoder_config_ = NULL;
  }
  if (from.has_video_decoder_config()) {
    video_decoder_config_ = new ::media::remoting::pb::VideoDecoderConfig(*from.video_decoder_config_);
  } else {
    video_decoder_config_ = NULL;
  }
  ::memcpy(&status_, &from.status_,
    static_cast<size_t>(reinterpret_cast<char*>(&count_) -
    reinterpret_cast<char*>(&status_)) + sizeof(count_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.DemuxerStreamReadUntilCallback)
}

void DemuxerStreamReadUntilCallback::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&audio_decoder_config_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&count_) -
      reinterpret_cast<char*>(&audio_decoder_config_)) + sizeof(count_));
}

DemuxerStreamReadUntilCallback::~DemuxerStreamReadUntilCallback() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.DemuxerStreamReadUntilCallback)
  SharedDtor();
}

void DemuxerStreamReadUntilCallback::SharedDtor() {
  if (this != internal_default_instance()) {
    delete audio_decoder_config_;
  }
  if (this != internal_default_instance()) {
    delete video_decoder_config_;
  }
}

void DemuxerStreamReadUntilCallback::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DemuxerStreamReadUntilCallback& DemuxerStreamReadUntilCallback::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

DemuxerStreamReadUntilCallback* DemuxerStreamReadUntilCallback::New(::google::protobuf::Arena* arena) const {
  DemuxerStreamReadUntilCallback* n = new DemuxerStreamReadUntilCallback;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DemuxerStreamReadUntilCallback::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.DemuxerStreamReadUntilCallback)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_audio_decoder_config()) {
      GOOGLE_DCHECK(audio_decoder_config_ != NULL);
      audio_decoder_config_->::media::remoting::pb::AudioDecoderConfig::Clear();
    }
    if (has_video_decoder_config()) {
      GOOGLE_DCHECK(video_decoder_config_ != NULL);
      video_decoder_config_->::media::remoting::pb::VideoDecoderConfig::Clear();
    }
  }
  if (_has_bits_[0 / 32] & 12u) {
    ::memset(&status_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&count_) -
        reinterpret_cast<char*>(&status_)) + sizeof(count_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DemuxerStreamReadUntilCallback::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.DemuxerStreamReadUntilCallback)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.DemuxerStreamReadUntilCallback.Status status = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::DemuxerStreamReadUntilCallback_Status_IsValid(value)) {
            set_status(static_cast< ::media::remoting::pb::DemuxerStreamReadUntilCallback_Status >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 count = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_count();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &count_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_audio_decoder_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_video_decoder_config()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.DemuxerStreamReadUntilCallback)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.DemuxerStreamReadUntilCallback)
  return false;
#undef DO_
}

void DemuxerStreamReadUntilCallback::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.DemuxerStreamReadUntilCallback)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.DemuxerStreamReadUntilCallback.Status status = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->status(), output);
  }

  // optional uint32 count = 2;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->count(), output);
  }

  // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, *this->audio_decoder_config_, output);
  }

  // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 4;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->video_decoder_config_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.DemuxerStreamReadUntilCallback)
}

size_t DemuxerStreamReadUntilCallback::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.DemuxerStreamReadUntilCallback)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 3;
    if (has_audio_decoder_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->audio_decoder_config_);
    }

    // optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 4;
    if (has_video_decoder_config()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->video_decoder_config_);
    }

    // optional .media.remoting.pb.DemuxerStreamReadUntilCallback.Status status = 1;
    if (has_status()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->status());
    }

    // optional uint32 count = 2;
    if (has_count()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->count());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DemuxerStreamReadUntilCallback::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DemuxerStreamReadUntilCallback*>(&from));
}

void DemuxerStreamReadUntilCallback::MergeFrom(const DemuxerStreamReadUntilCallback& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.DemuxerStreamReadUntilCallback)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_audio_decoder_config()->::media::remoting::pb::AudioDecoderConfig::MergeFrom(from.audio_decoder_config());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_video_decoder_config()->::media::remoting::pb::VideoDecoderConfig::MergeFrom(from.video_decoder_config());
    }
    if (cached_has_bits & 0x00000004u) {
      status_ = from.status_;
    }
    if (cached_has_bits & 0x00000008u) {
      count_ = from.count_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DemuxerStreamReadUntilCallback::CopyFrom(const DemuxerStreamReadUntilCallback& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.DemuxerStreamReadUntilCallback)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DemuxerStreamReadUntilCallback::IsInitialized() const {
  return true;
}

void DemuxerStreamReadUntilCallback::Swap(DemuxerStreamReadUntilCallback* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DemuxerStreamReadUntilCallback::InternalSwap(DemuxerStreamReadUntilCallback* other) {
  std::swap(audio_decoder_config_, other->audio_decoder_config_);
  std::swap(video_decoder_config_, other->video_decoder_config_);
  std::swap(status_, other->status_);
  std::swap(count_, other->count_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string DemuxerStreamReadUntilCallback::GetTypeName() const {
  return "media.remoting.pb.DemuxerStreamReadUntilCallback";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DemuxerStreamReadUntilCallback

// optional .media.remoting.pb.DemuxerStreamReadUntilCallback.Status status = 1;
bool DemuxerStreamReadUntilCallback::has_status() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void DemuxerStreamReadUntilCallback::set_has_status() {
  _has_bits_[0] |= 0x00000004u;
}
void DemuxerStreamReadUntilCallback::clear_has_status() {
  _has_bits_[0] &= ~0x00000004u;
}
void DemuxerStreamReadUntilCallback::clear_status() {
  status_ = 0;
  clear_has_status();
}
::media::remoting::pb::DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::status() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamReadUntilCallback.status)
  return static_cast< ::media::remoting::pb::DemuxerStreamReadUntilCallback_Status >(status_);
}
void DemuxerStreamReadUntilCallback::set_status(::media::remoting::pb::DemuxerStreamReadUntilCallback_Status value) {
  assert(::media::remoting::pb::DemuxerStreamReadUntilCallback_Status_IsValid(value));
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DemuxerStreamReadUntilCallback.status)
}

// optional uint32 count = 2;
bool DemuxerStreamReadUntilCallback::has_count() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void DemuxerStreamReadUntilCallback::set_has_count() {
  _has_bits_[0] |= 0x00000008u;
}
void DemuxerStreamReadUntilCallback::clear_has_count() {
  _has_bits_[0] &= ~0x00000008u;
}
void DemuxerStreamReadUntilCallback::clear_count() {
  count_ = 0u;
  clear_has_count();
}
::google::protobuf::uint32 DemuxerStreamReadUntilCallback::count() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamReadUntilCallback.count)
  return count_;
}
void DemuxerStreamReadUntilCallback::set_count(::google::protobuf::uint32 value) {
  set_has_count();
  count_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.DemuxerStreamReadUntilCallback.count)
}

// optional .media.remoting.pb.AudioDecoderConfig audio_decoder_config = 3;
bool DemuxerStreamReadUntilCallback::has_audio_decoder_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DemuxerStreamReadUntilCallback::set_has_audio_decoder_config() {
  _has_bits_[0] |= 0x00000001u;
}
void DemuxerStreamReadUntilCallback::clear_has_audio_decoder_config() {
  _has_bits_[0] &= ~0x00000001u;
}
void DemuxerStreamReadUntilCallback::clear_audio_decoder_config() {
  if (audio_decoder_config_ != NULL) audio_decoder_config_->::media::remoting::pb::AudioDecoderConfig::Clear();
  clear_has_audio_decoder_config();
}
const ::media::remoting::pb::AudioDecoderConfig& DemuxerStreamReadUntilCallback::audio_decoder_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamReadUntilCallback.audio_decoder_config)
  return audio_decoder_config_ != NULL ? *audio_decoder_config_
                         : *::media::remoting::pb::AudioDecoderConfig::internal_default_instance();
}
::media::remoting::pb::AudioDecoderConfig* DemuxerStreamReadUntilCallback::mutable_audio_decoder_config() {
  set_has_audio_decoder_config();
  if (audio_decoder_config_ == NULL) {
    audio_decoder_config_ = new ::media::remoting::pb::AudioDecoderConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DemuxerStreamReadUntilCallback.audio_decoder_config)
  return audio_decoder_config_;
}
::media::remoting::pb::AudioDecoderConfig* DemuxerStreamReadUntilCallback::release_audio_decoder_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DemuxerStreamReadUntilCallback.audio_decoder_config)
  clear_has_audio_decoder_config();
  ::media::remoting::pb::AudioDecoderConfig* temp = audio_decoder_config_;
  audio_decoder_config_ = NULL;
  return temp;
}
void DemuxerStreamReadUntilCallback::set_allocated_audio_decoder_config(::media::remoting::pb::AudioDecoderConfig* audio_decoder_config) {
  delete audio_decoder_config_;
  audio_decoder_config_ = audio_decoder_config;
  if (audio_decoder_config) {
    set_has_audio_decoder_config();
  } else {
    clear_has_audio_decoder_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DemuxerStreamReadUntilCallback.audio_decoder_config)
}

// optional .media.remoting.pb.VideoDecoderConfig video_decoder_config = 4;
bool DemuxerStreamReadUntilCallback::has_video_decoder_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DemuxerStreamReadUntilCallback::set_has_video_decoder_config() {
  _has_bits_[0] |= 0x00000002u;
}
void DemuxerStreamReadUntilCallback::clear_has_video_decoder_config() {
  _has_bits_[0] &= ~0x00000002u;
}
void DemuxerStreamReadUntilCallback::clear_video_decoder_config() {
  if (video_decoder_config_ != NULL) video_decoder_config_->::media::remoting::pb::VideoDecoderConfig::Clear();
  clear_has_video_decoder_config();
}
const ::media::remoting::pb::VideoDecoderConfig& DemuxerStreamReadUntilCallback::video_decoder_config() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.DemuxerStreamReadUntilCallback.video_decoder_config)
  return video_decoder_config_ != NULL ? *video_decoder_config_
                         : *::media::remoting::pb::VideoDecoderConfig::internal_default_instance();
}
::media::remoting::pb::VideoDecoderConfig* DemuxerStreamReadUntilCallback::mutable_video_decoder_config() {
  set_has_video_decoder_config();
  if (video_decoder_config_ == NULL) {
    video_decoder_config_ = new ::media::remoting::pb::VideoDecoderConfig;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.DemuxerStreamReadUntilCallback.video_decoder_config)
  return video_decoder_config_;
}
::media::remoting::pb::VideoDecoderConfig* DemuxerStreamReadUntilCallback::release_video_decoder_config() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.DemuxerStreamReadUntilCallback.video_decoder_config)
  clear_has_video_decoder_config();
  ::media::remoting::pb::VideoDecoderConfig* temp = video_decoder_config_;
  video_decoder_config_ = NULL;
  return temp;
}
void DemuxerStreamReadUntilCallback::set_allocated_video_decoder_config(::media::remoting::pb::VideoDecoderConfig* video_decoder_config) {
  delete video_decoder_config_;
  video_decoder_config_ = video_decoder_config;
  if (video_decoder_config) {
    set_has_video_decoder_config();
  } else {
    clear_has_video_decoder_config();
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.DemuxerStreamReadUntilCallback.video_decoder_config)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmInitialize::kKeySystemFieldNumber;
const int CdmInitialize::kSecurityOriginFieldNumber;
const int CdmInitialize::kAllowDistinctiveIdentifierFieldNumber;
const int CdmInitialize::kAllowPersistentStateFieldNumber;
const int CdmInitialize::kUseHwSecureCodecsFieldNumber;
const int CdmInitialize::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmInitialize::CdmInitialize()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmInitialize)
}
CdmInitialize::CdmInitialize(const CdmInitialize& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_system_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_key_system()) {
    key_system_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_system_);
  }
  security_origin_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_security_origin()) {
    security_origin_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.security_origin_);
  }
  ::memcpy(&allow_distinctive_identifier_, &from.allow_distinctive_identifier_,
    static_cast<size_t>(reinterpret_cast<char*>(&callback_handle_) -
    reinterpret_cast<char*>(&allow_distinctive_identifier_)) + sizeof(callback_handle_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmInitialize)
}

void CdmInitialize::SharedCtor() {
  _cached_size_ = 0;
  key_system_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  security_origin_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&allow_distinctive_identifier_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&callback_handle_) -
      reinterpret_cast<char*>(&allow_distinctive_identifier_)) + sizeof(callback_handle_));
}

CdmInitialize::~CdmInitialize() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmInitialize)
  SharedDtor();
}

void CdmInitialize::SharedDtor() {
  key_system_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  security_origin_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmInitialize::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmInitialize& CdmInitialize::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmInitialize* CdmInitialize::New(::google::protobuf::Arena* arena) const {
  CdmInitialize* n = new CdmInitialize;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmInitialize::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmInitialize)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_key_system()) {
      GOOGLE_DCHECK(!key_system_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*key_system_.UnsafeRawStringPointer())->clear();
    }
    if (has_security_origin()) {
      GOOGLE_DCHECK(!security_origin_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*security_origin_.UnsafeRawStringPointer())->clear();
    }
  }
  if (_has_bits_[0 / 32] & 60u) {
    ::memset(&allow_distinctive_identifier_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&callback_handle_) -
        reinterpret_cast<char*>(&allow_distinctive_identifier_)) + sizeof(callback_handle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmInitialize::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmInitialize)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string key_system = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_key_system()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string security_origin = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_security_origin()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool allow_distinctive_identifier = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_allow_distinctive_identifier();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &allow_distinctive_identifier_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool allow_persistent_state = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_allow_persistent_state();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &allow_persistent_state_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool use_hw_secure_codecs = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          set_has_use_hw_secure_codecs();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &use_hw_secure_codecs_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmInitialize)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmInitialize)
  return false;
#undef DO_
}

void CdmInitialize::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmInitialize)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string key_system = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->key_system(), output);
  }

  // optional string security_origin = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->security_origin(), output);
  }

  // optional bool allow_distinctive_identifier = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->allow_distinctive_identifier(), output);
  }

  // optional bool allow_persistent_state = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->allow_persistent_state(), output);
  }

  // optional bool use_hw_secure_codecs = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->use_hw_secure_codecs(), output);
  }

  // optional int32 callback_handle = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmInitialize)
}

size_t CdmInitialize::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmInitialize)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 63u) {
    // optional string key_system = 1;
    if (has_key_system()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->key_system());
    }

    // optional string security_origin = 2;
    if (has_security_origin()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->security_origin());
    }

    // optional bool allow_distinctive_identifier = 3;
    if (has_allow_distinctive_identifier()) {
      total_size += 1 + 1;
    }

    // optional bool allow_persistent_state = 4;
    if (has_allow_persistent_state()) {
      total_size += 1 + 1;
    }

    // optional bool use_hw_secure_codecs = 5;
    if (has_use_hw_secure_codecs()) {
      total_size += 1 + 1;
    }

    // optional int32 callback_handle = 6;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmInitialize::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmInitialize*>(&from));
}

void CdmInitialize::MergeFrom(const CdmInitialize& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmInitialize)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 63u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_key_system();
      key_system_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_system_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_security_origin();
      security_origin_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.security_origin_);
    }
    if (cached_has_bits & 0x00000004u) {
      allow_distinctive_identifier_ = from.allow_distinctive_identifier_;
    }
    if (cached_has_bits & 0x00000008u) {
      allow_persistent_state_ = from.allow_persistent_state_;
    }
    if (cached_has_bits & 0x00000010u) {
      use_hw_secure_codecs_ = from.use_hw_secure_codecs_;
    }
    if (cached_has_bits & 0x00000020u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmInitialize::CopyFrom(const CdmInitialize& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmInitialize)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmInitialize::IsInitialized() const {
  return true;
}

void CdmInitialize::Swap(CdmInitialize* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmInitialize::InternalSwap(CdmInitialize* other) {
  key_system_.Swap(&other->key_system_);
  security_origin_.Swap(&other->security_origin_);
  std::swap(allow_distinctive_identifier_, other->allow_distinctive_identifier_);
  std::swap(allow_persistent_state_, other->allow_persistent_state_);
  std::swap(use_hw_secure_codecs_, other->use_hw_secure_codecs_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmInitialize::GetTypeName() const {
  return "media.remoting.pb.CdmInitialize";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmInitialize

// optional string key_system = 1;
bool CdmInitialize::has_key_system() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmInitialize::set_has_key_system() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmInitialize::clear_has_key_system() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmInitialize::clear_key_system() {
  key_system_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key_system();
}
const ::std::string& CdmInitialize::key_system() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmInitialize.key_system)
  return key_system_.GetNoArena();
}
void CdmInitialize::set_key_system(const ::std::string& value) {
  set_has_key_system();
  key_system_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmInitialize.key_system)
}
#if LANG_CXX11
void CdmInitialize::set_key_system(::std::string&& value) {
  set_has_key_system();
  key_system_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmInitialize.key_system)
}
#endif
void CdmInitialize::set_key_system(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key_system();
  key_system_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmInitialize.key_system)
}
void CdmInitialize::set_key_system(const char* value, size_t size) {
  set_has_key_system();
  key_system_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmInitialize.key_system)
}
::std::string* CdmInitialize::mutable_key_system() {
  set_has_key_system();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmInitialize.key_system)
  return key_system_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmInitialize::release_key_system() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmInitialize.key_system)
  clear_has_key_system();
  return key_system_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmInitialize::set_allocated_key_system(::std::string* key_system) {
  if (key_system != NULL) {
    set_has_key_system();
  } else {
    clear_has_key_system();
  }
  key_system_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key_system);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmInitialize.key_system)
}

// optional string security_origin = 2;
bool CdmInitialize::has_security_origin() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmInitialize::set_has_security_origin() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmInitialize::clear_has_security_origin() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmInitialize::clear_security_origin() {
  security_origin_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_security_origin();
}
const ::std::string& CdmInitialize::security_origin() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmInitialize.security_origin)
  return security_origin_.GetNoArena();
}
void CdmInitialize::set_security_origin(const ::std::string& value) {
  set_has_security_origin();
  security_origin_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmInitialize.security_origin)
}
#if LANG_CXX11
void CdmInitialize::set_security_origin(::std::string&& value) {
  set_has_security_origin();
  security_origin_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmInitialize.security_origin)
}
#endif
void CdmInitialize::set_security_origin(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_security_origin();
  security_origin_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmInitialize.security_origin)
}
void CdmInitialize::set_security_origin(const char* value, size_t size) {
  set_has_security_origin();
  security_origin_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmInitialize.security_origin)
}
::std::string* CdmInitialize::mutable_security_origin() {
  set_has_security_origin();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmInitialize.security_origin)
  return security_origin_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmInitialize::release_security_origin() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmInitialize.security_origin)
  clear_has_security_origin();
  return security_origin_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmInitialize::set_allocated_security_origin(::std::string* security_origin) {
  if (security_origin != NULL) {
    set_has_security_origin();
  } else {
    clear_has_security_origin();
  }
  security_origin_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), security_origin);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmInitialize.security_origin)
}

// optional bool allow_distinctive_identifier = 3;
bool CdmInitialize::has_allow_distinctive_identifier() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmInitialize::set_has_allow_distinctive_identifier() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmInitialize::clear_has_allow_distinctive_identifier() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmInitialize::clear_allow_distinctive_identifier() {
  allow_distinctive_identifier_ = false;
  clear_has_allow_distinctive_identifier();
}
bool CdmInitialize::allow_distinctive_identifier() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmInitialize.allow_distinctive_identifier)
  return allow_distinctive_identifier_;
}
void CdmInitialize::set_allow_distinctive_identifier(bool value) {
  set_has_allow_distinctive_identifier();
  allow_distinctive_identifier_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmInitialize.allow_distinctive_identifier)
}

// optional bool allow_persistent_state = 4;
bool CdmInitialize::has_allow_persistent_state() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void CdmInitialize::set_has_allow_persistent_state() {
  _has_bits_[0] |= 0x00000008u;
}
void CdmInitialize::clear_has_allow_persistent_state() {
  _has_bits_[0] &= ~0x00000008u;
}
void CdmInitialize::clear_allow_persistent_state() {
  allow_persistent_state_ = false;
  clear_has_allow_persistent_state();
}
bool CdmInitialize::allow_persistent_state() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmInitialize.allow_persistent_state)
  return allow_persistent_state_;
}
void CdmInitialize::set_allow_persistent_state(bool value) {
  set_has_allow_persistent_state();
  allow_persistent_state_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmInitialize.allow_persistent_state)
}

// optional bool use_hw_secure_codecs = 5;
bool CdmInitialize::has_use_hw_secure_codecs() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void CdmInitialize::set_has_use_hw_secure_codecs() {
  _has_bits_[0] |= 0x00000010u;
}
void CdmInitialize::clear_has_use_hw_secure_codecs() {
  _has_bits_[0] &= ~0x00000010u;
}
void CdmInitialize::clear_use_hw_secure_codecs() {
  use_hw_secure_codecs_ = false;
  clear_has_use_hw_secure_codecs();
}
bool CdmInitialize::use_hw_secure_codecs() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmInitialize.use_hw_secure_codecs)
  return use_hw_secure_codecs_;
}
void CdmInitialize::set_use_hw_secure_codecs(bool value) {
  set_has_use_hw_secure_codecs();
  use_hw_secure_codecs_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmInitialize.use_hw_secure_codecs)
}

// optional int32 callback_handle = 6;
bool CdmInitialize::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void CdmInitialize::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000020u;
}
void CdmInitialize::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000020u;
}
void CdmInitialize::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmInitialize::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmInitialize.callback_handle)
  return callback_handle_;
}
void CdmInitialize::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmInitialize.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmSetServerCertificate::kCallbackHandleFieldNumber;
const int CdmSetServerCertificate::kCertificateDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmSetServerCertificate::CdmSetServerCertificate()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmSetServerCertificate)
}
CdmSetServerCertificate::CdmSetServerCertificate(const CdmSetServerCertificate& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  certificate_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_certificate_data()) {
    certificate_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.certificate_data_);
  }
  callback_handle_ = from.callback_handle_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmSetServerCertificate)
}

void CdmSetServerCertificate::SharedCtor() {
  _cached_size_ = 0;
  certificate_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  callback_handle_ = 0;
}

CdmSetServerCertificate::~CdmSetServerCertificate() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmSetServerCertificate)
  SharedDtor();
}

void CdmSetServerCertificate::SharedDtor() {
  certificate_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmSetServerCertificate::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmSetServerCertificate& CdmSetServerCertificate::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmSetServerCertificate* CdmSetServerCertificate::New(::google::protobuf::Arena* arena) const {
  CdmSetServerCertificate* n = new CdmSetServerCertificate;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmSetServerCertificate::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmSetServerCertificate)
  if (has_certificate_data()) {
    GOOGLE_DCHECK(!certificate_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*certificate_data_.UnsafeRawStringPointer())->clear();
  }
  callback_handle_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmSetServerCertificate::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmSetServerCertificate)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 callback_handle = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes certificate_data = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_certificate_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmSetServerCertificate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmSetServerCertificate)
  return false;
#undef DO_
}

void CdmSetServerCertificate::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmSetServerCertificate)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 callback_handle = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->callback_handle(), output);
  }

  // optional bytes certificate_data = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->certificate_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmSetServerCertificate)
}

size_t CdmSetServerCertificate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmSetServerCertificate)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional bytes certificate_data = 2;
    if (has_certificate_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->certificate_data());
    }

    // optional int32 callback_handle = 1;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmSetServerCertificate::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmSetServerCertificate*>(&from));
}

void CdmSetServerCertificate::MergeFrom(const CdmSetServerCertificate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmSetServerCertificate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_certificate_data();
      certificate_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.certificate_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmSetServerCertificate::CopyFrom(const CdmSetServerCertificate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmSetServerCertificate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmSetServerCertificate::IsInitialized() const {
  return true;
}

void CdmSetServerCertificate::Swap(CdmSetServerCertificate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmSetServerCertificate::InternalSwap(CdmSetServerCertificate* other) {
  certificate_data_.Swap(&other->certificate_data_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmSetServerCertificate::GetTypeName() const {
  return "media.remoting.pb.CdmSetServerCertificate";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmSetServerCertificate

// optional int32 callback_handle = 1;
bool CdmSetServerCertificate::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmSetServerCertificate::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmSetServerCertificate::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmSetServerCertificate::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmSetServerCertificate::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmSetServerCertificate.callback_handle)
  return callback_handle_;
}
void CdmSetServerCertificate::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmSetServerCertificate.callback_handle)
}

// optional bytes certificate_data = 2;
bool CdmSetServerCertificate::has_certificate_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmSetServerCertificate::set_has_certificate_data() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmSetServerCertificate::clear_has_certificate_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmSetServerCertificate::clear_certificate_data() {
  certificate_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_certificate_data();
}
const ::std::string& CdmSetServerCertificate::certificate_data() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmSetServerCertificate.certificate_data)
  return certificate_data_.GetNoArena();
}
void CdmSetServerCertificate::set_certificate_data(const ::std::string& value) {
  set_has_certificate_data();
  certificate_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmSetServerCertificate.certificate_data)
}
#if LANG_CXX11
void CdmSetServerCertificate::set_certificate_data(::std::string&& value) {
  set_has_certificate_data();
  certificate_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmSetServerCertificate.certificate_data)
}
#endif
void CdmSetServerCertificate::set_certificate_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_certificate_data();
  certificate_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmSetServerCertificate.certificate_data)
}
void CdmSetServerCertificate::set_certificate_data(const void* value, size_t size) {
  set_has_certificate_data();
  certificate_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmSetServerCertificate.certificate_data)
}
::std::string* CdmSetServerCertificate::mutable_certificate_data() {
  set_has_certificate_data();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmSetServerCertificate.certificate_data)
  return certificate_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmSetServerCertificate::release_certificate_data() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmSetServerCertificate.certificate_data)
  clear_has_certificate_data();
  return certificate_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmSetServerCertificate::set_allocated_certificate_data(::std::string* certificate_data) {
  if (certificate_data != NULL) {
    set_has_certificate_data();
  } else {
    clear_has_certificate_data();
  }
  certificate_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), certificate_data);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmSetServerCertificate.certificate_data)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmCreateSessionAndGenerateRequest::kSessionTypeFieldNumber;
const int CdmCreateSessionAndGenerateRequest::kInitDataTypeFieldNumber;
const int CdmCreateSessionAndGenerateRequest::kCallbackHandleFieldNumber;
const int CdmCreateSessionAndGenerateRequest::kInitDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmCreateSessionAndGenerateRequest::CdmCreateSessionAndGenerateRequest()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
}
CdmCreateSessionAndGenerateRequest::CdmCreateSessionAndGenerateRequest(const CdmCreateSessionAndGenerateRequest& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  init_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_init_data()) {
    init_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.init_data_);
  }
  ::memcpy(&session_type_, &from.session_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&callback_handle_) -
    reinterpret_cast<char*>(&session_type_)) + sizeof(callback_handle_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
}

void CdmCreateSessionAndGenerateRequest::SharedCtor() {
  _cached_size_ = 0;
  init_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&session_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&callback_handle_) -
      reinterpret_cast<char*>(&session_type_)) + sizeof(callback_handle_));
}

CdmCreateSessionAndGenerateRequest::~CdmCreateSessionAndGenerateRequest() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  SharedDtor();
}

void CdmCreateSessionAndGenerateRequest::SharedDtor() {
  init_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmCreateSessionAndGenerateRequest::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmCreateSessionAndGenerateRequest& CdmCreateSessionAndGenerateRequest::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmCreateSessionAndGenerateRequest* CdmCreateSessionAndGenerateRequest::New(::google::protobuf::Arena* arena) const {
  CdmCreateSessionAndGenerateRequest* n = new CdmCreateSessionAndGenerateRequest;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmCreateSessionAndGenerateRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  if (has_init_data()) {
    GOOGLE_DCHECK(!init_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*init_data_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 14u) {
    ::memset(&session_type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&callback_handle_) -
        reinterpret_cast<char*>(&session_type_)) + sizeof(callback_handle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmCreateSessionAndGenerateRequest::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.CdmSessionType session_type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::CdmSessionType_IsValid(value)) {
            set_session_type(static_cast< ::media::remoting::pb::CdmSessionType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest.EmeInitDataType init_data_type = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::CdmCreateSessionAndGenerateRequest_EmeInitDataType_IsValid(value)) {
            set_init_data_type(static_cast< ::media::remoting::pb::CdmCreateSessionAndGenerateRequest_EmeInitDataType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes init_data = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_init_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  return false;
#undef DO_
}

void CdmCreateSessionAndGenerateRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.CdmSessionType session_type = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->session_type(), output);
  }

  // optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest.EmeInitDataType init_data_type = 2;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->init_data_type(), output);
  }

  // optional int32 callback_handle = 3;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->callback_handle(), output);
  }

  // optional bytes init_data = 4;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      4, this->init_data(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
}

size_t CdmCreateSessionAndGenerateRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 15u) {
    // optional bytes init_data = 4;
    if (has_init_data()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->init_data());
    }

    // optional .media.remoting.pb.CdmSessionType session_type = 1;
    if (has_session_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->session_type());
    }

    // optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest.EmeInitDataType init_data_type = 2;
    if (has_init_data_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->init_data_type());
    }

    // optional int32 callback_handle = 3;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmCreateSessionAndGenerateRequest::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmCreateSessionAndGenerateRequest*>(&from));
}

void CdmCreateSessionAndGenerateRequest::MergeFrom(const CdmCreateSessionAndGenerateRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 15u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_init_data();
      init_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.init_data_);
    }
    if (cached_has_bits & 0x00000002u) {
      session_type_ = from.session_type_;
    }
    if (cached_has_bits & 0x00000004u) {
      init_data_type_ = from.init_data_type_;
    }
    if (cached_has_bits & 0x00000008u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmCreateSessionAndGenerateRequest::CopyFrom(const CdmCreateSessionAndGenerateRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmCreateSessionAndGenerateRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmCreateSessionAndGenerateRequest::IsInitialized() const {
  return true;
}

void CdmCreateSessionAndGenerateRequest::Swap(CdmCreateSessionAndGenerateRequest* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmCreateSessionAndGenerateRequest::InternalSwap(CdmCreateSessionAndGenerateRequest* other) {
  init_data_.Swap(&other->init_data_);
  std::swap(session_type_, other->session_type_);
  std::swap(init_data_type_, other->init_data_type_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmCreateSessionAndGenerateRequest::GetTypeName() const {
  return "media.remoting.pb.CdmCreateSessionAndGenerateRequest";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmCreateSessionAndGenerateRequest

// optional .media.remoting.pb.CdmSessionType session_type = 1;
bool CdmCreateSessionAndGenerateRequest::has_session_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmCreateSessionAndGenerateRequest::set_has_session_type() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmCreateSessionAndGenerateRequest::clear_has_session_type() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmCreateSessionAndGenerateRequest::clear_session_type() {
  session_type_ = 0;
  clear_has_session_type();
}
::media::remoting::pb::CdmSessionType CdmCreateSessionAndGenerateRequest::session_type() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmCreateSessionAndGenerateRequest.session_type)
  return static_cast< ::media::remoting::pb::CdmSessionType >(session_type_);
}
void CdmCreateSessionAndGenerateRequest::set_session_type(::media::remoting::pb::CdmSessionType value) {
  assert(::media::remoting::pb::CdmSessionType_IsValid(value));
  set_has_session_type();
  session_type_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmCreateSessionAndGenerateRequest.session_type)
}

// optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest.EmeInitDataType init_data_type = 2;
bool CdmCreateSessionAndGenerateRequest::has_init_data_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmCreateSessionAndGenerateRequest::set_has_init_data_type() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmCreateSessionAndGenerateRequest::clear_has_init_data_type() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmCreateSessionAndGenerateRequest::clear_init_data_type() {
  init_data_type_ = 0;
  clear_has_init_data_type();
}
::media::remoting::pb::CdmCreateSessionAndGenerateRequest_EmeInitDataType CdmCreateSessionAndGenerateRequest::init_data_type() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data_type)
  return static_cast< ::media::remoting::pb::CdmCreateSessionAndGenerateRequest_EmeInitDataType >(init_data_type_);
}
void CdmCreateSessionAndGenerateRequest::set_init_data_type(::media::remoting::pb::CdmCreateSessionAndGenerateRequest_EmeInitDataType value) {
  assert(::media::remoting::pb::CdmCreateSessionAndGenerateRequest_EmeInitDataType_IsValid(value));
  set_has_init_data_type();
  init_data_type_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data_type)
}

// optional int32 callback_handle = 3;
bool CdmCreateSessionAndGenerateRequest::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void CdmCreateSessionAndGenerateRequest::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000008u;
}
void CdmCreateSessionAndGenerateRequest::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000008u;
}
void CdmCreateSessionAndGenerateRequest::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmCreateSessionAndGenerateRequest::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmCreateSessionAndGenerateRequest.callback_handle)
  return callback_handle_;
}
void CdmCreateSessionAndGenerateRequest::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmCreateSessionAndGenerateRequest.callback_handle)
}

// optional bytes init_data = 4;
bool CdmCreateSessionAndGenerateRequest::has_init_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmCreateSessionAndGenerateRequest::set_has_init_data() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmCreateSessionAndGenerateRequest::clear_has_init_data() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmCreateSessionAndGenerateRequest::clear_init_data() {
  init_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_init_data();
}
const ::std::string& CdmCreateSessionAndGenerateRequest::init_data() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
  return init_data_.GetNoArena();
}
void CdmCreateSessionAndGenerateRequest::set_init_data(const ::std::string& value) {
  set_has_init_data();
  init_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
}
#if LANG_CXX11
void CdmCreateSessionAndGenerateRequest::set_init_data(::std::string&& value) {
  set_has_init_data();
  init_data_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
}
#endif
void CdmCreateSessionAndGenerateRequest::set_init_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_init_data();
  init_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
}
void CdmCreateSessionAndGenerateRequest::set_init_data(const void* value, size_t size) {
  set_has_init_data();
  init_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
}
::std::string* CdmCreateSessionAndGenerateRequest::mutable_init_data() {
  set_has_init_data();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
  return init_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmCreateSessionAndGenerateRequest::release_init_data() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
  clear_has_init_data();
  return init_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmCreateSessionAndGenerateRequest::set_allocated_init_data(::std::string* init_data) {
  if (init_data != NULL) {
    set_has_init_data();
  } else {
    clear_has_init_data();
  }
  init_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), init_data);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmCreateSessionAndGenerateRequest.init_data)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmLoadSession::kSessionTypeFieldNumber;
const int CdmLoadSession::kSessionIdFieldNumber;
const int CdmLoadSession::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmLoadSession::CdmLoadSession()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmLoadSession)
}
CdmLoadSession::CdmLoadSession(const CdmLoadSession& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  ::memcpy(&session_type_, &from.session_type_,
    static_cast<size_t>(reinterpret_cast<char*>(&callback_handle_) -
    reinterpret_cast<char*>(&session_type_)) + sizeof(callback_handle_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmLoadSession)
}

void CdmLoadSession::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&session_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&callback_handle_) -
      reinterpret_cast<char*>(&session_type_)) + sizeof(callback_handle_));
}

CdmLoadSession::~CdmLoadSession() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmLoadSession)
  SharedDtor();
}

void CdmLoadSession::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmLoadSession::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmLoadSession& CdmLoadSession::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmLoadSession* CdmLoadSession::New(::google::protobuf::Arena* arena) const {
  CdmLoadSession* n = new CdmLoadSession;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmLoadSession::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmLoadSession)
  if (has_session_id()) {
    GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*session_id_.UnsafeRawStringPointer())->clear();
  }
  if (_has_bits_[0 / 32] & 6u) {
    ::memset(&session_type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&callback_handle_) -
        reinterpret_cast<char*>(&session_type_)) + sizeof(callback_handle_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmLoadSession::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmLoadSession)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .media.remoting.pb.CdmSessionType session_type = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::CdmSessionType_IsValid(value)) {
            set_session_type(static_cast< ::media::remoting::pb::CdmSessionType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string session_id = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmLoadSession)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmLoadSession)
  return false;
#undef DO_
}

void CdmLoadSession::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmLoadSession)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .media.remoting.pb.CdmSessionType session_type = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->session_type(), output);
  }

  // optional string session_id = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->session_id(), output);
  }

  // optional int32 callback_handle = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmLoadSession)
}

size_t CdmLoadSession::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmLoadSession)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional string session_id = 2;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional .media.remoting.pb.CdmSessionType session_type = 1;
    if (has_session_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->session_type());
    }

    // optional int32 callback_handle = 3;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmLoadSession::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmLoadSession*>(&from));
}

void CdmLoadSession::MergeFrom(const CdmLoadSession& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmLoadSession)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      session_type_ = from.session_type_;
    }
    if (cached_has_bits & 0x00000004u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmLoadSession::CopyFrom(const CdmLoadSession& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmLoadSession)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmLoadSession::IsInitialized() const {
  return true;
}

void CdmLoadSession::Swap(CdmLoadSession* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmLoadSession::InternalSwap(CdmLoadSession* other) {
  session_id_.Swap(&other->session_id_);
  std::swap(session_type_, other->session_type_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmLoadSession::GetTypeName() const {
  return "media.remoting.pb.CdmLoadSession";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmLoadSession

// optional .media.remoting.pb.CdmSessionType session_type = 1;
bool CdmLoadSession::has_session_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmLoadSession::set_has_session_type() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmLoadSession::clear_has_session_type() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmLoadSession::clear_session_type() {
  session_type_ = 0;
  clear_has_session_type();
}
::media::remoting::pb::CdmSessionType CdmLoadSession::session_type() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmLoadSession.session_type)
  return static_cast< ::media::remoting::pb::CdmSessionType >(session_type_);
}
void CdmLoadSession::set_session_type(::media::remoting::pb::CdmSessionType value) {
  assert(::media::remoting::pb::CdmSessionType_IsValid(value));
  set_has_session_type();
  session_type_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmLoadSession.session_type)
}

// optional string session_id = 2;
bool CdmLoadSession::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmLoadSession::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmLoadSession::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmLoadSession::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmLoadSession::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmLoadSession.session_id)
  return session_id_.GetNoArena();
}
void CdmLoadSession::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmLoadSession.session_id)
}
#if LANG_CXX11
void CdmLoadSession::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmLoadSession.session_id)
}
#endif
void CdmLoadSession::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmLoadSession.session_id)
}
void CdmLoadSession::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmLoadSession.session_id)
}
::std::string* CdmLoadSession::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmLoadSession.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmLoadSession::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmLoadSession.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmLoadSession::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmLoadSession.session_id)
}

// optional int32 callback_handle = 3;
bool CdmLoadSession::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmLoadSession::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmLoadSession::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmLoadSession::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmLoadSession::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmLoadSession.callback_handle)
  return callback_handle_;
}
void CdmLoadSession::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmLoadSession.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmUpdateSession::kSessionIdFieldNumber;
const int CdmUpdateSession::kCallbackHandleFieldNumber;
const int CdmUpdateSession::kResponseFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmUpdateSession::CdmUpdateSession()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmUpdateSession)
}
CdmUpdateSession::CdmUpdateSession(const CdmUpdateSession& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  response_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_response()) {
    response_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.response_);
  }
  callback_handle_ = from.callback_handle_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmUpdateSession)
}

void CdmUpdateSession::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  response_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  callback_handle_ = 0;
}

CdmUpdateSession::~CdmUpdateSession() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmUpdateSession)
  SharedDtor();
}

void CdmUpdateSession::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  response_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmUpdateSession::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmUpdateSession& CdmUpdateSession::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmUpdateSession* CdmUpdateSession::New(::google::protobuf::Arena* arena) const {
  CdmUpdateSession* n = new CdmUpdateSession;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmUpdateSession::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmUpdateSession)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_session_id()) {
      GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*session_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_response()) {
      GOOGLE_DCHECK(!response_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*response_.UnsafeRawStringPointer())->clear();
    }
  }
  callback_handle_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmUpdateSession::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmUpdateSession)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string session_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes response = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_response()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmUpdateSession)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmUpdateSession)
  return false;
#undef DO_
}

void CdmUpdateSession::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmUpdateSession)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string session_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->session_id(), output);
  }

  // optional int32 callback_handle = 2;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->callback_handle(), output);
  }

  // optional bytes response = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->response(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmUpdateSession)
}

size_t CdmUpdateSession::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmUpdateSession)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional string session_id = 1;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional bytes response = 3;
    if (has_response()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->response());
    }

    // optional int32 callback_handle = 2;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmUpdateSession::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmUpdateSession*>(&from));
}

void CdmUpdateSession::MergeFrom(const CdmUpdateSession& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmUpdateSession)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_response();
      response_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.response_);
    }
    if (cached_has_bits & 0x00000004u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmUpdateSession::CopyFrom(const CdmUpdateSession& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmUpdateSession)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmUpdateSession::IsInitialized() const {
  return true;
}

void CdmUpdateSession::Swap(CdmUpdateSession* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmUpdateSession::InternalSwap(CdmUpdateSession* other) {
  session_id_.Swap(&other->session_id_);
  response_.Swap(&other->response_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmUpdateSession::GetTypeName() const {
  return "media.remoting.pb.CdmUpdateSession";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmUpdateSession

// optional string session_id = 1;
bool CdmUpdateSession::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmUpdateSession::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmUpdateSession::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmUpdateSession::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmUpdateSession::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmUpdateSession.session_id)
  return session_id_.GetNoArena();
}
void CdmUpdateSession::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmUpdateSession.session_id)
}
#if LANG_CXX11
void CdmUpdateSession::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmUpdateSession.session_id)
}
#endif
void CdmUpdateSession::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmUpdateSession.session_id)
}
void CdmUpdateSession::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmUpdateSession.session_id)
}
::std::string* CdmUpdateSession::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmUpdateSession.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmUpdateSession::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmUpdateSession.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmUpdateSession::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmUpdateSession.session_id)
}

// optional int32 callback_handle = 2;
bool CdmUpdateSession::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmUpdateSession::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmUpdateSession::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmUpdateSession::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmUpdateSession::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmUpdateSession.callback_handle)
  return callback_handle_;
}
void CdmUpdateSession::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmUpdateSession.callback_handle)
}

// optional bytes response = 3;
bool CdmUpdateSession::has_response() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmUpdateSession::set_has_response() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmUpdateSession::clear_has_response() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmUpdateSession::clear_response() {
  response_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_response();
}
const ::std::string& CdmUpdateSession::response() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmUpdateSession.response)
  return response_.GetNoArena();
}
void CdmUpdateSession::set_response(const ::std::string& value) {
  set_has_response();
  response_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmUpdateSession.response)
}
#if LANG_CXX11
void CdmUpdateSession::set_response(::std::string&& value) {
  set_has_response();
  response_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmUpdateSession.response)
}
#endif
void CdmUpdateSession::set_response(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_response();
  response_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmUpdateSession.response)
}
void CdmUpdateSession::set_response(const void* value, size_t size) {
  set_has_response();
  response_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmUpdateSession.response)
}
::std::string* CdmUpdateSession::mutable_response() {
  set_has_response();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmUpdateSession.response)
  return response_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmUpdateSession::release_response() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmUpdateSession.response)
  clear_has_response();
  return response_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmUpdateSession::set_allocated_response(::std::string* response) {
  if (response != NULL) {
    set_has_response();
  } else {
    clear_has_response();
  }
  response_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), response);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmUpdateSession.response)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmCloseSession::kSessionIdFieldNumber;
const int CdmCloseSession::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmCloseSession::CdmCloseSession()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmCloseSession)
}
CdmCloseSession::CdmCloseSession(const CdmCloseSession& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  callback_handle_ = from.callback_handle_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmCloseSession)
}

void CdmCloseSession::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  callback_handle_ = 0;
}

CdmCloseSession::~CdmCloseSession() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmCloseSession)
  SharedDtor();
}

void CdmCloseSession::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmCloseSession::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmCloseSession& CdmCloseSession::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmCloseSession* CdmCloseSession::New(::google::protobuf::Arena* arena) const {
  CdmCloseSession* n = new CdmCloseSession;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmCloseSession::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmCloseSession)
  if (has_session_id()) {
    GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*session_id_.UnsafeRawStringPointer())->clear();
  }
  callback_handle_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmCloseSession::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmCloseSession)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string session_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmCloseSession)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmCloseSession)
  return false;
#undef DO_
}

void CdmCloseSession::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmCloseSession)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string session_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->session_id(), output);
  }

  // optional int32 callback_handle = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmCloseSession)
}

size_t CdmCloseSession::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmCloseSession)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional string session_id = 1;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional int32 callback_handle = 2;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmCloseSession::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmCloseSession*>(&from));
}

void CdmCloseSession::MergeFrom(const CdmCloseSession& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmCloseSession)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmCloseSession::CopyFrom(const CdmCloseSession& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmCloseSession)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmCloseSession::IsInitialized() const {
  return true;
}

void CdmCloseSession::Swap(CdmCloseSession* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmCloseSession::InternalSwap(CdmCloseSession* other) {
  session_id_.Swap(&other->session_id_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmCloseSession::GetTypeName() const {
  return "media.remoting.pb.CdmCloseSession";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmCloseSession

// optional string session_id = 1;
bool CdmCloseSession::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmCloseSession::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmCloseSession::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmCloseSession::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmCloseSession::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmCloseSession.session_id)
  return session_id_.GetNoArena();
}
void CdmCloseSession::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmCloseSession.session_id)
}
#if LANG_CXX11
void CdmCloseSession::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmCloseSession.session_id)
}
#endif
void CdmCloseSession::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmCloseSession.session_id)
}
void CdmCloseSession::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmCloseSession.session_id)
}
::std::string* CdmCloseSession::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmCloseSession.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmCloseSession::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmCloseSession.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmCloseSession::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmCloseSession.session_id)
}

// optional int32 callback_handle = 2;
bool CdmCloseSession::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmCloseSession::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmCloseSession::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmCloseSession::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmCloseSession::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmCloseSession.callback_handle)
  return callback_handle_;
}
void CdmCloseSession::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmCloseSession.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmRemoveSession::kSessionIdFieldNumber;
const int CdmRemoveSession::kCallbackHandleFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmRemoveSession::CdmRemoveSession()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmRemoveSession)
}
CdmRemoveSession::CdmRemoveSession(const CdmRemoveSession& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  callback_handle_ = from.callback_handle_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmRemoveSession)
}

void CdmRemoveSession::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  callback_handle_ = 0;
}

CdmRemoveSession::~CdmRemoveSession() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmRemoveSession)
  SharedDtor();
}

void CdmRemoveSession::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmRemoveSession::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmRemoveSession& CdmRemoveSession::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmRemoveSession* CdmRemoveSession::New(::google::protobuf::Arena* arena) const {
  CdmRemoveSession* n = new CdmRemoveSession;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmRemoveSession::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmRemoveSession)
  if (has_session_id()) {
    GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*session_id_.UnsafeRawStringPointer())->clear();
  }
  callback_handle_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmRemoveSession::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmRemoveSession)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string session_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 callback_handle = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_callback_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &callback_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmRemoveSession)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmRemoveSession)
  return false;
#undef DO_
}

void CdmRemoveSession::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmRemoveSession)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string session_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->session_id(), output);
  }

  // optional int32 callback_handle = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->callback_handle(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmRemoveSession)
}

size_t CdmRemoveSession::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmRemoveSession)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional string session_id = 1;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional int32 callback_handle = 2;
    if (has_callback_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->callback_handle());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmRemoveSession::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmRemoveSession*>(&from));
}

void CdmRemoveSession::MergeFrom(const CdmRemoveSession& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmRemoveSession)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      callback_handle_ = from.callback_handle_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmRemoveSession::CopyFrom(const CdmRemoveSession& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmRemoveSession)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmRemoveSession::IsInitialized() const {
  return true;
}

void CdmRemoveSession::Swap(CdmRemoveSession* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmRemoveSession::InternalSwap(CdmRemoveSession* other) {
  session_id_.Swap(&other->session_id_);
  std::swap(callback_handle_, other->callback_handle_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmRemoveSession::GetTypeName() const {
  return "media.remoting.pb.CdmRemoveSession";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmRemoveSession

// optional string session_id = 1;
bool CdmRemoveSession::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmRemoveSession::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmRemoveSession::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmRemoveSession::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmRemoveSession::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmRemoveSession.session_id)
  return session_id_.GetNoArena();
}
void CdmRemoveSession::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmRemoveSession.session_id)
}
#if LANG_CXX11
void CdmRemoveSession::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmRemoveSession.session_id)
}
#endif
void CdmRemoveSession::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmRemoveSession.session_id)
}
void CdmRemoveSession::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmRemoveSession.session_id)
}
::std::string* CdmRemoveSession::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmRemoveSession.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmRemoveSession::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmRemoveSession.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmRemoveSession::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmRemoveSession.session_id)
}

// optional int32 callback_handle = 2;
bool CdmRemoveSession::has_callback_handle() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmRemoveSession::set_has_callback_handle() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmRemoveSession::clear_has_callback_handle() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmRemoveSession::clear_callback_handle() {
  callback_handle_ = 0;
  clear_has_callback_handle();
}
::google::protobuf::int32 CdmRemoveSession::callback_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmRemoveSession.callback_handle)
  return callback_handle_;
}
void CdmRemoveSession::set_callback_handle(::google::protobuf::int32 value) {
  set_has_callback_handle();
  callback_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmRemoveSession.callback_handle)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmPromise::kCdmIdFieldNumber;
const int CdmPromise::kDecryptorHandleFieldNumber;
const int CdmPromise::kSessionIdFieldNumber;
const int CdmPromise::kSuccessFieldNumber;
const int CdmPromise::kExceptionFieldNumber;
const int CdmPromise::kSystemCodeFieldNumber;
const int CdmPromise::kErrorMessageFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmPromise::CdmPromise()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmPromise)
}
CdmPromise::CdmPromise(const CdmPromise& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  error_message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_error_message()) {
    error_message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.error_message_);
  }
  ::memcpy(&cdm_id_, &from.cdm_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&system_code_) -
    reinterpret_cast<char*>(&cdm_id_)) + sizeof(system_code_));
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmPromise)
}

void CdmPromise::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  error_message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&cdm_id_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&system_code_) -
      reinterpret_cast<char*>(&cdm_id_)) + sizeof(system_code_));
}

CdmPromise::~CdmPromise() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmPromise)
  SharedDtor();
}

void CdmPromise::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  error_message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmPromise::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmPromise& CdmPromise::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmPromise* CdmPromise::New(::google::protobuf::Arena* arena) const {
  CdmPromise* n = new CdmPromise;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmPromise::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmPromise)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_session_id()) {
      GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*session_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_error_message()) {
      GOOGLE_DCHECK(!error_message_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*error_message_.UnsafeRawStringPointer())->clear();
    }
  }
  if (_has_bits_[0 / 32] & 124u) {
    ::memset(&cdm_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&system_code_) -
        reinterpret_cast<char*>(&cdm_id_)) + sizeof(system_code_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmPromise::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmPromise)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 cdm_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_cdm_id();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &cdm_id_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 decryptor_handle = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_decryptor_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &decryptor_handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string session_id = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool success = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          set_has_success();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &success_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmException exception = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::CdmException_IsValid(value)) {
            set_exception(static_cast< ::media::remoting::pb::CdmException >(value));
          } else {
            unknown_fields_stream.WriteVarint32(40u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 system_code = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          set_has_system_code();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &system_code_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string error_message = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_error_message()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmPromise)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmPromise)
  return false;
#undef DO_
}

void CdmPromise::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmPromise)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 cdm_id = 1;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->cdm_id(), output);
  }

  // optional int32 decryptor_handle = 2;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->decryptor_handle(), output);
  }

  // optional string session_id = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->session_id(), output);
  }

  // optional bool success = 4;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->success(), output);
  }

  // optional .media.remoting.pb.CdmException exception = 5;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->exception(), output);
  }

  // optional uint32 system_code = 6;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->system_code(), output);
  }

  // optional string error_message = 7;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      7, this->error_message(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmPromise)
}

size_t CdmPromise::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmPromise)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 127u) {
    // optional string session_id = 3;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional string error_message = 7;
    if (has_error_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->error_message());
    }

    // optional int32 cdm_id = 1;
    if (has_cdm_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->cdm_id());
    }

    // optional int32 decryptor_handle = 2;
    if (has_decryptor_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->decryptor_handle());
    }

    // optional bool success = 4;
    if (has_success()) {
      total_size += 1 + 1;
    }

    // optional .media.remoting.pb.CdmException exception = 5;
    if (has_exception()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->exception());
    }

    // optional uint32 system_code = 6;
    if (has_system_code()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->system_code());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmPromise::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmPromise*>(&from));
}

void CdmPromise::MergeFrom(const CdmPromise& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmPromise)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 127u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_error_message();
      error_message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.error_message_);
    }
    if (cached_has_bits & 0x00000004u) {
      cdm_id_ = from.cdm_id_;
    }
    if (cached_has_bits & 0x00000008u) {
      decryptor_handle_ = from.decryptor_handle_;
    }
    if (cached_has_bits & 0x00000010u) {
      success_ = from.success_;
    }
    if (cached_has_bits & 0x00000020u) {
      exception_ = from.exception_;
    }
    if (cached_has_bits & 0x00000040u) {
      system_code_ = from.system_code_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmPromise::CopyFrom(const CdmPromise& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmPromise)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmPromise::IsInitialized() const {
  return true;
}

void CdmPromise::Swap(CdmPromise* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmPromise::InternalSwap(CdmPromise* other) {
  session_id_.Swap(&other->session_id_);
  error_message_.Swap(&other->error_message_);
  std::swap(cdm_id_, other->cdm_id_);
  std::swap(decryptor_handle_, other->decryptor_handle_);
  std::swap(success_, other->success_);
  std::swap(exception_, other->exception_);
  std::swap(system_code_, other->system_code_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmPromise::GetTypeName() const {
  return "media.remoting.pb.CdmPromise";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmPromise

// optional int32 cdm_id = 1;
bool CdmPromise::has_cdm_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmPromise::set_has_cdm_id() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmPromise::clear_has_cdm_id() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmPromise::clear_cdm_id() {
  cdm_id_ = 0;
  clear_has_cdm_id();
}
::google::protobuf::int32 CdmPromise::cdm_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.cdm_id)
  return cdm_id_;
}
void CdmPromise::set_cdm_id(::google::protobuf::int32 value) {
  set_has_cdm_id();
  cdm_id_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.cdm_id)
}

// optional int32 decryptor_handle = 2;
bool CdmPromise::has_decryptor_handle() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void CdmPromise::set_has_decryptor_handle() {
  _has_bits_[0] |= 0x00000008u;
}
void CdmPromise::clear_has_decryptor_handle() {
  _has_bits_[0] &= ~0x00000008u;
}
void CdmPromise::clear_decryptor_handle() {
  decryptor_handle_ = 0;
  clear_has_decryptor_handle();
}
::google::protobuf::int32 CdmPromise::decryptor_handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.decryptor_handle)
  return decryptor_handle_;
}
void CdmPromise::set_decryptor_handle(::google::protobuf::int32 value) {
  set_has_decryptor_handle();
  decryptor_handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.decryptor_handle)
}

// optional string session_id = 3;
bool CdmPromise::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmPromise::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmPromise::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmPromise::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmPromise::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.session_id)
  return session_id_.GetNoArena();
}
void CdmPromise::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.session_id)
}
#if LANG_CXX11
void CdmPromise::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmPromise.session_id)
}
#endif
void CdmPromise::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmPromise.session_id)
}
void CdmPromise::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmPromise.session_id)
}
::std::string* CdmPromise::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmPromise.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmPromise::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmPromise.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmPromise::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmPromise.session_id)
}

// optional bool success = 4;
bool CdmPromise::has_success() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void CdmPromise::set_has_success() {
  _has_bits_[0] |= 0x00000010u;
}
void CdmPromise::clear_has_success() {
  _has_bits_[0] &= ~0x00000010u;
}
void CdmPromise::clear_success() {
  success_ = false;
  clear_has_success();
}
bool CdmPromise::success() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.success)
  return success_;
}
void CdmPromise::set_success(bool value) {
  set_has_success();
  success_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.success)
}

// optional .media.remoting.pb.CdmException exception = 5;
bool CdmPromise::has_exception() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void CdmPromise::set_has_exception() {
  _has_bits_[0] |= 0x00000020u;
}
void CdmPromise::clear_has_exception() {
  _has_bits_[0] &= ~0x00000020u;
}
void CdmPromise::clear_exception() {
  exception_ = 0;
  clear_has_exception();
}
::media::remoting::pb::CdmException CdmPromise::exception() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.exception)
  return static_cast< ::media::remoting::pb::CdmException >(exception_);
}
void CdmPromise::set_exception(::media::remoting::pb::CdmException value) {
  assert(::media::remoting::pb::CdmException_IsValid(value));
  set_has_exception();
  exception_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.exception)
}

// optional uint32 system_code = 6;
bool CdmPromise::has_system_code() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void CdmPromise::set_has_system_code() {
  _has_bits_[0] |= 0x00000040u;
}
void CdmPromise::clear_has_system_code() {
  _has_bits_[0] &= ~0x00000040u;
}
void CdmPromise::clear_system_code() {
  system_code_ = 0u;
  clear_has_system_code();
}
::google::protobuf::uint32 CdmPromise::system_code() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.system_code)
  return system_code_;
}
void CdmPromise::set_system_code(::google::protobuf::uint32 value) {
  set_has_system_code();
  system_code_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.system_code)
}

// optional string error_message = 7;
bool CdmPromise::has_error_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmPromise::set_has_error_message() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmPromise::clear_has_error_message() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmPromise::clear_error_message() {
  error_message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_error_message();
}
const ::std::string& CdmPromise::error_message() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmPromise.error_message)
  return error_message_.GetNoArena();
}
void CdmPromise::set_error_message(const ::std::string& value) {
  set_has_error_message();
  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmPromise.error_message)
}
#if LANG_CXX11
void CdmPromise::set_error_message(::std::string&& value) {
  set_has_error_message();
  error_message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmPromise.error_message)
}
#endif
void CdmPromise::set_error_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_error_message();
  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmPromise.error_message)
}
void CdmPromise::set_error_message(const char* value, size_t size) {
  set_has_error_message();
  error_message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmPromise.error_message)
}
::std::string* CdmPromise::mutable_error_message() {
  set_has_error_message();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmPromise.error_message)
  return error_message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmPromise::release_error_message() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmPromise.error_message)
  clear_has_error_message();
  return error_message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmPromise::set_allocated_error_message(::std::string* error_message) {
  if (error_message != NULL) {
    set_has_error_message();
  } else {
    clear_has_error_message();
  }
  error_message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error_message);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmPromise.error_message)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmClientOnSessionMessage::kSessionIdFieldNumber;
const int CdmClientOnSessionMessage::kMessageTypeFieldNumber;
const int CdmClientOnSessionMessage::kMessageFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmClientOnSessionMessage::CdmClientOnSessionMessage()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmClientOnSessionMessage)
}
CdmClientOnSessionMessage::CdmClientOnSessionMessage(const CdmClientOnSessionMessage& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_message()) {
    message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
  }
  message_type_ = from.message_type_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmClientOnSessionMessage)
}

void CdmClientOnSessionMessage::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  message_type_ = 0;
}

CdmClientOnSessionMessage::~CdmClientOnSessionMessage() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmClientOnSessionMessage)
  SharedDtor();
}

void CdmClientOnSessionMessage::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmClientOnSessionMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmClientOnSessionMessage& CdmClientOnSessionMessage::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmClientOnSessionMessage* CdmClientOnSessionMessage::New(::google::protobuf::Arena* arena) const {
  CdmClientOnSessionMessage* n = new CdmClientOnSessionMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmClientOnSessionMessage::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmClientOnSessionMessage)
  if (_has_bits_[0 / 32] & 3u) {
    if (has_session_id()) {
      GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*session_id_.UnsafeRawStringPointer())->clear();
    }
    if (has_message()) {
      GOOGLE_DCHECK(!message_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
      (*message_.UnsafeRawStringPointer())->clear();
    }
  }
  message_type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmClientOnSessionMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmClientOnSessionMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string session_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmMessageType message_type = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::CdmMessageType_IsValid(value)) {
            set_message_type(static_cast< ::media::remoting::pb::CdmMessageType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes message = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_message()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmClientOnSessionMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmClientOnSessionMessage)
  return false;
#undef DO_
}

void CdmClientOnSessionMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmClientOnSessionMessage)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string session_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->session_id(), output);
  }

  // optional .media.remoting.pb.CdmMessageType message_type = 2;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->message_type(), output);
  }

  // optional bytes message = 3;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      3, this->message(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmClientOnSessionMessage)
}

size_t CdmClientOnSessionMessage::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmClientOnSessionMessage)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 7u) {
    // optional string session_id = 1;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional bytes message = 3;
    if (has_message()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::BytesSize(
          this->message());
    }

    // optional .media.remoting.pb.CdmMessageType message_type = 2;
    if (has_message_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->message_type());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmClientOnSessionMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmClientOnSessionMessage*>(&from));
}

void CdmClientOnSessionMessage::MergeFrom(const CdmClientOnSessionMessage& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmClientOnSessionMessage)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 7u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_message();
      message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_);
    }
    if (cached_has_bits & 0x00000004u) {
      message_type_ = from.message_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmClientOnSessionMessage::CopyFrom(const CdmClientOnSessionMessage& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmClientOnSessionMessage)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmClientOnSessionMessage::IsInitialized() const {
  return true;
}

void CdmClientOnSessionMessage::Swap(CdmClientOnSessionMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmClientOnSessionMessage::InternalSwap(CdmClientOnSessionMessage* other) {
  session_id_.Swap(&other->session_id_);
  message_.Swap(&other->message_);
  std::swap(message_type_, other->message_type_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmClientOnSessionMessage::GetTypeName() const {
  return "media.remoting.pb.CdmClientOnSessionMessage";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmClientOnSessionMessage

// optional string session_id = 1;
bool CdmClientOnSessionMessage::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmClientOnSessionMessage::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmClientOnSessionMessage::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmClientOnSessionMessage::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmClientOnSessionMessage::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionMessage.session_id)
  return session_id_.GetNoArena();
}
void CdmClientOnSessionMessage::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionMessage.session_id)
}
#if LANG_CXX11
void CdmClientOnSessionMessage::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmClientOnSessionMessage.session_id)
}
#endif
void CdmClientOnSessionMessage::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmClientOnSessionMessage.session_id)
}
void CdmClientOnSessionMessage::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmClientOnSessionMessage.session_id)
}
::std::string* CdmClientOnSessionMessage::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmClientOnSessionMessage.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmClientOnSessionMessage::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmClientOnSessionMessage.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmClientOnSessionMessage::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmClientOnSessionMessage.session_id)
}

// optional .media.remoting.pb.CdmMessageType message_type = 2;
bool CdmClientOnSessionMessage::has_message_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void CdmClientOnSessionMessage::set_has_message_type() {
  _has_bits_[0] |= 0x00000004u;
}
void CdmClientOnSessionMessage::clear_has_message_type() {
  _has_bits_[0] &= ~0x00000004u;
}
void CdmClientOnSessionMessage::clear_message_type() {
  message_type_ = 0;
  clear_has_message_type();
}
::media::remoting::pb::CdmMessageType CdmClientOnSessionMessage::message_type() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionMessage.message_type)
  return static_cast< ::media::remoting::pb::CdmMessageType >(message_type_);
}
void CdmClientOnSessionMessage::set_message_type(::media::remoting::pb::CdmMessageType value) {
  assert(::media::remoting::pb::CdmMessageType_IsValid(value));
  set_has_message_type();
  message_type_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionMessage.message_type)
}

// optional bytes message = 3;
bool CdmClientOnSessionMessage::has_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmClientOnSessionMessage::set_has_message() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmClientOnSessionMessage::clear_has_message() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmClientOnSessionMessage::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
const ::std::string& CdmClientOnSessionMessage::message() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionMessage.message)
  return message_.GetNoArena();
}
void CdmClientOnSessionMessage::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionMessage.message)
}
#if LANG_CXX11
void CdmClientOnSessionMessage::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmClientOnSessionMessage.message)
}
#endif
void CdmClientOnSessionMessage::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmClientOnSessionMessage.message)
}
void CdmClientOnSessionMessage::set_message(const void* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmClientOnSessionMessage.message)
}
::std::string* CdmClientOnSessionMessage::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmClientOnSessionMessage.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmClientOnSessionMessage::release_message() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmClientOnSessionMessage.message)
  clear_has_message();
  return message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmClientOnSessionMessage::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmClientOnSessionMessage.message)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmClientOnSessionKeysChange::kSessionIdFieldNumber;
const int CdmClientOnSessionKeysChange::kHasAdditionalUsableKeyFieldNumber;
const int CdmClientOnSessionKeysChange::kKeyInformationFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmClientOnSessionKeysChange::CdmClientOnSessionKeysChange()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmClientOnSessionKeysChange)
}
CdmClientOnSessionKeysChange::CdmClientOnSessionKeysChange(const CdmClientOnSessionKeysChange& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0),
      key_information_(from.key_information_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  has_additional_usable_key_ = from.has_additional_usable_key_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmClientOnSessionKeysChange)
}

void CdmClientOnSessionKeysChange::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  has_additional_usable_key_ = false;
}

CdmClientOnSessionKeysChange::~CdmClientOnSessionKeysChange() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmClientOnSessionKeysChange)
  SharedDtor();
}

void CdmClientOnSessionKeysChange::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmClientOnSessionKeysChange::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmClientOnSessionKeysChange& CdmClientOnSessionKeysChange::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmClientOnSessionKeysChange* CdmClientOnSessionKeysChange::New(::google::protobuf::Arena* arena) const {
  CdmClientOnSessionKeysChange* n = new CdmClientOnSessionKeysChange;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmClientOnSessionKeysChange::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmClientOnSessionKeysChange)
  key_information_.Clear();
  if (has_session_id()) {
    GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*session_id_.UnsafeRawStringPointer())->clear();
  }
  has_additional_usable_key_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmClientOnSessionKeysChange::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmClientOnSessionKeysChange)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string session_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool has_additional_usable_key = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_has_additional_usable_key();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &has_additional_usable_key_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated .media.remoting.pb.CdmKeyInformation key_information = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_key_information()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmClientOnSessionKeysChange)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmClientOnSessionKeysChange)
  return false;
#undef DO_
}

void CdmClientOnSessionKeysChange::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmClientOnSessionKeysChange)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string session_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->session_id(), output);
  }

  // optional bool has_additional_usable_key = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->has_additional_usable_key(), output);
  }

  // repeated .media.remoting.pb.CdmKeyInformation key_information = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->key_information_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->key_information(static_cast<int>(i)), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmClientOnSessionKeysChange)
}

size_t CdmClientOnSessionKeysChange::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmClientOnSessionKeysChange)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // repeated .media.remoting.pb.CdmKeyInformation key_information = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->key_information_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->key_information(static_cast<int>(i)));
    }
  }

  if (_has_bits_[0 / 32] & 3u) {
    // optional string session_id = 1;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional bool has_additional_usable_key = 2;
    if (has_has_additional_usable_key()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmClientOnSessionKeysChange::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmClientOnSessionKeysChange*>(&from));
}

void CdmClientOnSessionKeysChange::MergeFrom(const CdmClientOnSessionKeysChange& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmClientOnSessionKeysChange)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  key_information_.MergeFrom(from.key_information_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      has_additional_usable_key_ = from.has_additional_usable_key_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmClientOnSessionKeysChange::CopyFrom(const CdmClientOnSessionKeysChange& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmClientOnSessionKeysChange)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmClientOnSessionKeysChange::IsInitialized() const {
  return true;
}

void CdmClientOnSessionKeysChange::Swap(CdmClientOnSessionKeysChange* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmClientOnSessionKeysChange::InternalSwap(CdmClientOnSessionKeysChange* other) {
  key_information_.InternalSwap(&other->key_information_);
  session_id_.Swap(&other->session_id_);
  std::swap(has_additional_usable_key_, other->has_additional_usable_key_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmClientOnSessionKeysChange::GetTypeName() const {
  return "media.remoting.pb.CdmClientOnSessionKeysChange";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmClientOnSessionKeysChange

// optional string session_id = 1;
bool CdmClientOnSessionKeysChange::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmClientOnSessionKeysChange::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmClientOnSessionKeysChange::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmClientOnSessionKeysChange::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmClientOnSessionKeysChange::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
  return session_id_.GetNoArena();
}
void CdmClientOnSessionKeysChange::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
}
#if LANG_CXX11
void CdmClientOnSessionKeysChange::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
}
#endif
void CdmClientOnSessionKeysChange::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
}
void CdmClientOnSessionKeysChange::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
}
::std::string* CdmClientOnSessionKeysChange::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmClientOnSessionKeysChange::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmClientOnSessionKeysChange::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmClientOnSessionKeysChange.session_id)
}

// optional bool has_additional_usable_key = 2;
bool CdmClientOnSessionKeysChange::has_has_additional_usable_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmClientOnSessionKeysChange::set_has_has_additional_usable_key() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmClientOnSessionKeysChange::clear_has_has_additional_usable_key() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmClientOnSessionKeysChange::clear_has_additional_usable_key() {
  has_additional_usable_key_ = false;
  clear_has_has_additional_usable_key();
}
bool CdmClientOnSessionKeysChange::has_additional_usable_key() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionKeysChange.has_additional_usable_key)
  return has_additional_usable_key_;
}
void CdmClientOnSessionKeysChange::set_has_additional_usable_key(bool value) {
  set_has_has_additional_usable_key();
  has_additional_usable_key_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionKeysChange.has_additional_usable_key)
}

// repeated .media.remoting.pb.CdmKeyInformation key_information = 3;
int CdmClientOnSessionKeysChange::key_information_size() const {
  return key_information_.size();
}
void CdmClientOnSessionKeysChange::clear_key_information() {
  key_information_.Clear();
}
const ::media::remoting::pb::CdmKeyInformation& CdmClientOnSessionKeysChange::key_information(int index) const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionKeysChange.key_information)
  return key_information_.Get(index);
}
::media::remoting::pb::CdmKeyInformation* CdmClientOnSessionKeysChange::mutable_key_information(int index) {
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmClientOnSessionKeysChange.key_information)
  return key_information_.Mutable(index);
}
::media::remoting::pb::CdmKeyInformation* CdmClientOnSessionKeysChange::add_key_information() {
  // @@protoc_insertion_point(field_add:media.remoting.pb.CdmClientOnSessionKeysChange.key_information)
  return key_information_.Add();
}
::google::protobuf::RepeatedPtrField< ::media::remoting::pb::CdmKeyInformation >*
CdmClientOnSessionKeysChange::mutable_key_information() {
  // @@protoc_insertion_point(field_mutable_list:media.remoting.pb.CdmClientOnSessionKeysChange.key_information)
  return &key_information_;
}
const ::google::protobuf::RepeatedPtrField< ::media::remoting::pb::CdmKeyInformation >&
CdmClientOnSessionKeysChange::key_information() const {
  // @@protoc_insertion_point(field_list:media.remoting.pb.CdmClientOnSessionKeysChange.key_information)
  return key_information_;
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int CdmClientOnSessionExpirationUpdate::kSessionIdFieldNumber;
const int CdmClientOnSessionExpirationUpdate::kNewExpiryTimeSecFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

CdmClientOnSessionExpirationUpdate::CdmClientOnSessionExpirationUpdate()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
}
CdmClientOnSessionExpirationUpdate::CdmClientOnSessionExpirationUpdate(const CdmClientOnSessionExpirationUpdate& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_session_id()) {
    session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
  }
  new_expiry_time_sec_ = from.new_expiry_time_sec_;
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
}

void CdmClientOnSessionExpirationUpdate::SharedCtor() {
  _cached_size_ = 0;
  session_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  new_expiry_time_sec_ = 0;
}

CdmClientOnSessionExpirationUpdate::~CdmClientOnSessionExpirationUpdate() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  SharedDtor();
}

void CdmClientOnSessionExpirationUpdate::SharedDtor() {
  session_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void CdmClientOnSessionExpirationUpdate::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CdmClientOnSessionExpirationUpdate& CdmClientOnSessionExpirationUpdate::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

CdmClientOnSessionExpirationUpdate* CdmClientOnSessionExpirationUpdate::New(::google::protobuf::Arena* arena) const {
  CdmClientOnSessionExpirationUpdate* n = new CdmClientOnSessionExpirationUpdate;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void CdmClientOnSessionExpirationUpdate::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  if (has_session_id()) {
    GOOGLE_DCHECK(!session_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*session_id_.UnsafeRawStringPointer())->clear();
  }
  new_expiry_time_sec_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool CdmClientOnSessionExpirationUpdate::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional string session_id = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_session_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional double new_expiry_time_sec = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(17u)) {
          set_has_new_expiry_time_sec();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &new_expiry_time_sec_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  return false;
#undef DO_
}

void CdmClientOnSessionExpirationUpdate::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string session_id = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->session_id(), output);
  }

  // optional double new_expiry_time_sec = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->new_expiry_time_sec(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
}

size_t CdmClientOnSessionExpirationUpdate::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional string session_id = 1;
    if (has_session_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->session_id());
    }

    // optional double new_expiry_time_sec = 2;
    if (has_new_expiry_time_sec()) {
      total_size += 1 + 8;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CdmClientOnSessionExpirationUpdate::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CdmClientOnSessionExpirationUpdate*>(&from));
}

void CdmClientOnSessionExpirationUpdate::MergeFrom(const CdmClientOnSessionExpirationUpdate& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_session_id();
      session_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.session_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      new_expiry_time_sec_ = from.new_expiry_time_sec_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void CdmClientOnSessionExpirationUpdate::CopyFrom(const CdmClientOnSessionExpirationUpdate& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.CdmClientOnSessionExpirationUpdate)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CdmClientOnSessionExpirationUpdate::IsInitialized() const {
  return true;
}

void CdmClientOnSessionExpirationUpdate::Swap(CdmClientOnSessionExpirationUpdate* other) {
  if (other == this) return;
  InternalSwap(other);
}
void CdmClientOnSessionExpirationUpdate::InternalSwap(CdmClientOnSessionExpirationUpdate* other) {
  session_id_.Swap(&other->session_id_);
  std::swap(new_expiry_time_sec_, other->new_expiry_time_sec_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string CdmClientOnSessionExpirationUpdate::GetTypeName() const {
  return "media.remoting.pb.CdmClientOnSessionExpirationUpdate";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// CdmClientOnSessionExpirationUpdate

// optional string session_id = 1;
bool CdmClientOnSessionExpirationUpdate::has_session_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void CdmClientOnSessionExpirationUpdate::set_has_session_id() {
  _has_bits_[0] |= 0x00000001u;
}
void CdmClientOnSessionExpirationUpdate::clear_has_session_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void CdmClientOnSessionExpirationUpdate::clear_session_id() {
  session_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_session_id();
}
const ::std::string& CdmClientOnSessionExpirationUpdate::session_id() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
  return session_id_.GetNoArena();
}
void CdmClientOnSessionExpirationUpdate::set_session_id(const ::std::string& value) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
}
#if LANG_CXX11
void CdmClientOnSessionExpirationUpdate::set_session_id(::std::string&& value) {
  set_has_session_id();
  session_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
}
#endif
void CdmClientOnSessionExpirationUpdate::set_session_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
}
void CdmClientOnSessionExpirationUpdate::set_session_id(const char* value, size_t size) {
  set_has_session_id();
  session_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
}
::std::string* CdmClientOnSessionExpirationUpdate::mutable_session_id() {
  set_has_session_id();
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
  return session_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* CdmClientOnSessionExpirationUpdate::release_session_id() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
  clear_has_session_id();
  return session_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void CdmClientOnSessionExpirationUpdate::set_allocated_session_id(::std::string* session_id) {
  if (session_id != NULL) {
    set_has_session_id();
  } else {
    clear_has_session_id();
  }
  session_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), session_id);
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.CdmClientOnSessionExpirationUpdate.session_id)
}

// optional double new_expiry_time_sec = 2;
bool CdmClientOnSessionExpirationUpdate::has_new_expiry_time_sec() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void CdmClientOnSessionExpirationUpdate::set_has_new_expiry_time_sec() {
  _has_bits_[0] |= 0x00000002u;
}
void CdmClientOnSessionExpirationUpdate::clear_has_new_expiry_time_sec() {
  _has_bits_[0] &= ~0x00000002u;
}
void CdmClientOnSessionExpirationUpdate::clear_new_expiry_time_sec() {
  new_expiry_time_sec_ = 0;
  clear_has_new_expiry_time_sec();
}
double CdmClientOnSessionExpirationUpdate::new_expiry_time_sec() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.CdmClientOnSessionExpirationUpdate.new_expiry_time_sec)
  return new_expiry_time_sec_;
}
void CdmClientOnSessionExpirationUpdate::set_new_expiry_time_sec(double value) {
  set_has_new_expiry_time_sec();
  new_expiry_time_sec_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.CdmClientOnSessionExpirationUpdate.new_expiry_time_sec)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// ===================================================================

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RpcMessage::kHandleFieldNumber;
const int RpcMessage::kProcFieldNumber;
const int RpcMessage::kIntegerValueFieldNumber;
const int RpcMessage::kInteger64ValueFieldNumber;
const int RpcMessage::kDoubleValueFieldNumber;
const int RpcMessage::kBooleanValueFieldNumber;
const int RpcMessage::kStringValueFieldNumber;
const int RpcMessage::kRendererInitializeRpcFieldNumber;
const int RpcMessage::kRendererFlushuntilRpcFieldNumber;
const int RpcMessage::kRendererSetCdmRpcFieldNumber;
const int RpcMessage::kRendererclientOntimeupdateRpcFieldNumber;
const int RpcMessage::kRendererclientOnvideonatualsizechangeRpcFieldNumber;
const int RpcMessage::kRendererclientOnstatisticsupdateRpcFieldNumber;
const int RpcMessage::kRendererclientOnbufferingstatechangeRpcFieldNumber;
const int RpcMessage::kRendererclientOnaudioconfigchangeRpcFieldNumber;
const int RpcMessage::kRendererclientOnvideoconfigchangeRpcFieldNumber;
const int RpcMessage::kDemuxerstreamReaduntilRpcFieldNumber;
const int RpcMessage::kDemuxerstreamInitializecbRpcFieldNumber;
const int RpcMessage::kDemuxerstreamReaduntilcbRpcFieldNumber;
const int RpcMessage::kCdmInitializeRpcFieldNumber;
const int RpcMessage::kCdmSetservercertificateRpcFieldNumber;
const int RpcMessage::kCdmCreatesessionandgeneraterequestRpcFieldNumber;
const int RpcMessage::kCdmLoadsessionRpcFieldNumber;
const int RpcMessage::kCdmUpdatesessionRpcFieldNumber;
const int RpcMessage::kCdmClosesessionRpcFieldNumber;
const int RpcMessage::kCdmRemovesessionRpcFieldNumber;
const int RpcMessage::kCdmPromiseRpcFieldNumber;
const int RpcMessage::kCdmclientOnsessionmessageRpcFieldNumber;
const int RpcMessage::kCdmclientOnsessionkeychangeRpcFieldNumber;
const int RpcMessage::kCdmclientOnsessionexpirationupdateRpcFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

RpcMessage::RpcMessage()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_rpc_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:media.remoting.pb.RpcMessage)
}
RpcMessage::RpcMessage(const RpcMessage& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&handle_, &from.handle_,
    static_cast<size_t>(reinterpret_cast<char*>(&proc_) -
    reinterpret_cast<char*>(&handle_)) + sizeof(proc_));
  clear_has_rpc_oneof();
  switch (from.rpc_oneof_case()) {
    case kIntegerValue: {
      set_integer_value(from.integer_value());
      break;
    }
    case kInteger64Value: {
      set_integer64_value(from.integer64_value());
      break;
    }
    case kDoubleValue: {
      set_double_value(from.double_value());
      break;
    }
    case kBooleanValue: {
      set_boolean_value(from.boolean_value());
      break;
    }
    case kStringValue: {
      set_string_value(from.string_value());
      break;
    }
    case kRendererInitializeRpc: {
      mutable_renderer_initialize_rpc()->::media::remoting::pb::RendererInitialize::MergeFrom(from.renderer_initialize_rpc());
      break;
    }
    case kRendererFlushuntilRpc: {
      mutable_renderer_flushuntil_rpc()->::media::remoting::pb::RendererFlushUntil::MergeFrom(from.renderer_flushuntil_rpc());
      break;
    }
    case kRendererSetCdmRpc: {
      mutable_renderer_set_cdm_rpc()->::media::remoting::pb::RendererSetCdm::MergeFrom(from.renderer_set_cdm_rpc());
      break;
    }
    case kRendererclientOntimeupdateRpc: {
      mutable_rendererclient_ontimeupdate_rpc()->::media::remoting::pb::RendererClientOnTimeUpdate::MergeFrom(from.rendererclient_ontimeupdate_rpc());
      break;
    }
    case kRendererclientOnvideonatualsizechangeRpc: {
      mutable_rendererclient_onvideonatualsizechange_rpc()->::media::remoting::pb::Size::MergeFrom(from.rendererclient_onvideonatualsizechange_rpc());
      break;
    }
    case kRendererclientOnstatisticsupdateRpc: {
      mutable_rendererclient_onstatisticsupdate_rpc()->::media::remoting::pb::PipelineStatistics::MergeFrom(from.rendererclient_onstatisticsupdate_rpc());
      break;
    }
    case kRendererclientOnbufferingstatechangeRpc: {
      mutable_rendererclient_onbufferingstatechange_rpc()->::media::remoting::pb::RendererClientOnBufferingStateChange::MergeFrom(from.rendererclient_onbufferingstatechange_rpc());
      break;
    }
    case kRendererclientOnaudioconfigchangeRpc: {
      mutable_rendererclient_onaudioconfigchange_rpc()->::media::remoting::pb::RendererClientOnAudioConfigChange::MergeFrom(from.rendererclient_onaudioconfigchange_rpc());
      break;
    }
    case kRendererclientOnvideoconfigchangeRpc: {
      mutable_rendererclient_onvideoconfigchange_rpc()->::media::remoting::pb::RendererClientOnVideoConfigChange::MergeFrom(from.rendererclient_onvideoconfigchange_rpc());
      break;
    }
    case kDemuxerstreamReaduntilRpc: {
      mutable_demuxerstream_readuntil_rpc()->::media::remoting::pb::DemuxerStreamReadUntil::MergeFrom(from.demuxerstream_readuntil_rpc());
      break;
    }
    case kDemuxerstreamInitializecbRpc: {
      mutable_demuxerstream_initializecb_rpc()->::media::remoting::pb::DemuxerStreamInitializeCallback::MergeFrom(from.demuxerstream_initializecb_rpc());
      break;
    }
    case kDemuxerstreamReaduntilcbRpc: {
      mutable_demuxerstream_readuntilcb_rpc()->::media::remoting::pb::DemuxerStreamReadUntilCallback::MergeFrom(from.demuxerstream_readuntilcb_rpc());
      break;
    }
    case kCdmInitializeRpc: {
      mutable_cdm_initialize_rpc()->::media::remoting::pb::CdmInitialize::MergeFrom(from.cdm_initialize_rpc());
      break;
    }
    case kCdmSetservercertificateRpc: {
      mutable_cdm_setservercertificate_rpc()->::media::remoting::pb::CdmSetServerCertificate::MergeFrom(from.cdm_setservercertificate_rpc());
      break;
    }
    case kCdmCreatesessionandgeneraterequestRpc: {
      mutable_cdm_createsessionandgeneraterequest_rpc()->::media::remoting::pb::CdmCreateSessionAndGenerateRequest::MergeFrom(from.cdm_createsessionandgeneraterequest_rpc());
      break;
    }
    case kCdmLoadsessionRpc: {
      mutable_cdm_loadsession_rpc()->::media::remoting::pb::CdmLoadSession::MergeFrom(from.cdm_loadsession_rpc());
      break;
    }
    case kCdmUpdatesessionRpc: {
      mutable_cdm_updatesession_rpc()->::media::remoting::pb::CdmUpdateSession::MergeFrom(from.cdm_updatesession_rpc());
      break;
    }
    case kCdmClosesessionRpc: {
      mutable_cdm_closesession_rpc()->::media::remoting::pb::CdmCloseSession::MergeFrom(from.cdm_closesession_rpc());
      break;
    }
    case kCdmRemovesessionRpc: {
      mutable_cdm_removesession_rpc()->::media::remoting::pb::CdmRemoveSession::MergeFrom(from.cdm_removesession_rpc());
      break;
    }
    case kCdmPromiseRpc: {
      mutable_cdm_promise_rpc()->::media::remoting::pb::CdmPromise::MergeFrom(from.cdm_promise_rpc());
      break;
    }
    case kCdmclientOnsessionmessageRpc: {
      mutable_cdmclient_onsessionmessage_rpc()->::media::remoting::pb::CdmClientOnSessionMessage::MergeFrom(from.cdmclient_onsessionmessage_rpc());
      break;
    }
    case kCdmclientOnsessionkeychangeRpc: {
      mutable_cdmclient_onsessionkeychange_rpc()->::media::remoting::pb::CdmClientOnSessionKeysChange::MergeFrom(from.cdmclient_onsessionkeychange_rpc());
      break;
    }
    case kCdmclientOnsessionexpirationupdateRpc: {
      mutable_cdmclient_onsessionexpirationupdate_rpc()->::media::remoting::pb::CdmClientOnSessionExpirationUpdate::MergeFrom(from.cdmclient_onsessionexpirationupdate_rpc());
      break;
    }
    case RPC_ONEOF_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:media.remoting.pb.RpcMessage)
}

void RpcMessage::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&handle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&proc_) -
      reinterpret_cast<char*>(&handle_)) + sizeof(proc_));
  clear_has_rpc_oneof();
}

RpcMessage::~RpcMessage() {
  // @@protoc_insertion_point(destructor:media.remoting.pb.RpcMessage)
  SharedDtor();
}

void RpcMessage::SharedDtor() {
  if (has_rpc_oneof()) {
    clear_rpc_oneof();
  }
}

void RpcMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const RpcMessage& RpcMessage::default_instance() {
  protobuf_rpc_2eproto::InitDefaults();
  return *internal_default_instance();
}

RpcMessage* RpcMessage::New(::google::protobuf::Arena* arena) const {
  RpcMessage* n = new RpcMessage;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void RpcMessage::clear_rpc_oneof() {
// @@protoc_insertion_point(one_of_clear_start:media.remoting.pb.RpcMessage)
  switch (rpc_oneof_case()) {
    case kIntegerValue: {
      // No need to clear
      break;
    }
    case kInteger64Value: {
      // No need to clear
      break;
    }
    case kDoubleValue: {
      // No need to clear
      break;
    }
    case kBooleanValue: {
      // No need to clear
      break;
    }
    case kStringValue: {
      rpc_oneof_.string_value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kRendererInitializeRpc: {
      delete rpc_oneof_.renderer_initialize_rpc_;
      break;
    }
    case kRendererFlushuntilRpc: {
      delete rpc_oneof_.renderer_flushuntil_rpc_;
      break;
    }
    case kRendererSetCdmRpc: {
      delete rpc_oneof_.renderer_set_cdm_rpc_;
      break;
    }
    case kRendererclientOntimeupdateRpc: {
      delete rpc_oneof_.rendererclient_ontimeupdate_rpc_;
      break;
    }
    case kRendererclientOnvideonatualsizechangeRpc: {
      delete rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_;
      break;
    }
    case kRendererclientOnstatisticsupdateRpc: {
      delete rpc_oneof_.rendererclient_onstatisticsupdate_rpc_;
      break;
    }
    case kRendererclientOnbufferingstatechangeRpc: {
      delete rpc_oneof_.rendererclient_onbufferingstatechange_rpc_;
      break;
    }
    case kRendererclientOnaudioconfigchangeRpc: {
      delete rpc_oneof_.rendererclient_onaudioconfigchange_rpc_;
      break;
    }
    case kRendererclientOnvideoconfigchangeRpc: {
      delete rpc_oneof_.rendererclient_onvideoconfigchange_rpc_;
      break;
    }
    case kDemuxerstreamReaduntilRpc: {
      delete rpc_oneof_.demuxerstream_readuntil_rpc_;
      break;
    }
    case kDemuxerstreamInitializecbRpc: {
      delete rpc_oneof_.demuxerstream_initializecb_rpc_;
      break;
    }
    case kDemuxerstreamReaduntilcbRpc: {
      delete rpc_oneof_.demuxerstream_readuntilcb_rpc_;
      break;
    }
    case kCdmInitializeRpc: {
      delete rpc_oneof_.cdm_initialize_rpc_;
      break;
    }
    case kCdmSetservercertificateRpc: {
      delete rpc_oneof_.cdm_setservercertificate_rpc_;
      break;
    }
    case kCdmCreatesessionandgeneraterequestRpc: {
      delete rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_;
      break;
    }
    case kCdmLoadsessionRpc: {
      delete rpc_oneof_.cdm_loadsession_rpc_;
      break;
    }
    case kCdmUpdatesessionRpc: {
      delete rpc_oneof_.cdm_updatesession_rpc_;
      break;
    }
    case kCdmClosesessionRpc: {
      delete rpc_oneof_.cdm_closesession_rpc_;
      break;
    }
    case kCdmRemovesessionRpc: {
      delete rpc_oneof_.cdm_removesession_rpc_;
      break;
    }
    case kCdmPromiseRpc: {
      delete rpc_oneof_.cdm_promise_rpc_;
      break;
    }
    case kCdmclientOnsessionmessageRpc: {
      delete rpc_oneof_.cdmclient_onsessionmessage_rpc_;
      break;
    }
    case kCdmclientOnsessionkeychangeRpc: {
      delete rpc_oneof_.cdmclient_onsessionkeychange_rpc_;
      break;
    }
    case kCdmclientOnsessionexpirationupdateRpc: {
      delete rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_;
      break;
    }
    case RPC_ONEOF_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = RPC_ONEOF_NOT_SET;
}


void RpcMessage::Clear() {
// @@protoc_insertion_point(message_clear_start:media.remoting.pb.RpcMessage)
  if (_has_bits_[0 / 32] & 3u) {
    ::memset(&handle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&proc_) -
        reinterpret_cast<char*>(&handle_)) + sizeof(proc_));
  }
  clear_rpc_oneof();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool RpcMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:media.remoting.pb.RpcMessage)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 handle = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_handle();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &handle_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RpcMessage.RpcProc proc = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::media::remoting::pb::RpcMessage_RpcProc_IsValid(value)) {
            set_proc(static_cast< ::media::remoting::pb::RpcMessage_RpcProc >(value));
          } else {
            unknown_fields_stream.WriteVarint32(16u);
            unknown_fields_stream.WriteVarint32(
                static_cast< ::google::protobuf::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 integer_value = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(24u)) {
          clear_rpc_oneof();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &rpc_oneof_.integer_value_)));
          set_has_integer_value();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 integer64_value = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u)) {
          clear_rpc_oneof();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &rpc_oneof_.integer64_value_)));
          set_has_integer64_value();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional double double_value = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(41u)) {
          clear_rpc_oneof();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &rpc_oneof_.double_value_)));
          set_has_double_value();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool boolean_value = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u)) {
          clear_rpc_oneof();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &rpc_oneof_.boolean_value_)));
          set_has_boolean_value();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string string_value = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_string_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererInitialize renderer_initialize_rpc = 100;
      case 100: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_renderer_initialize_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererFlushUntil renderer_flushuntil_rpc = 101;
      case 101: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_renderer_flushuntil_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererSetCdm renderer_set_cdm_rpc = 102;
      case 102: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_renderer_set_cdm_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererClientOnTimeUpdate rendererclient_ontimeupdate_rpc = 200;
      case 200: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rendererclient_ontimeupdate_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.Size rendererclient_onvideonatualsizechange_rpc = 201;
      case 201: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rendererclient_onvideonatualsizechange_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.PipelineStatistics rendererclient_onstatisticsupdate_rpc = 202;
      case 202: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(82u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rendererclient_onstatisticsupdate_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererClientOnBufferingStateChange rendererclient_onbufferingstatechange_rpc = 203;
      case 203: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(90u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rendererclient_onbufferingstatechange_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererClientOnAudioConfigChange rendererclient_onaudioconfigchange_rpc = 204;
      case 204: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rendererclient_onaudioconfigchange_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.RendererClientOnVideoConfigChange rendererclient_onvideoconfigchange_rpc = 205;
      case 205: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_rendererclient_onvideoconfigchange_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.DemuxerStreamReadUntil demuxerstream_readuntil_rpc = 300;
      case 300: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(98u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_demuxerstream_readuntil_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.DemuxerStreamInitializeCallback demuxerstream_initializecb_rpc = 400;
      case 400: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(130u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_demuxerstream_initializecb_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.DemuxerStreamReadUntilCallback demuxerstream_readuntilcb_rpc = 401;
      case 401: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(138u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_demuxerstream_readuntilcb_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmInitialize cdm_initialize_rpc = 500;
      case 500: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(162u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_initialize_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmSetServerCertificate cdm_setservercertificate_rpc = 501;
      case 501: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(170u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_setservercertificate_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest cdm_createsessionandgeneraterequest_rpc = 502;
      case 502: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(178u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_createsessionandgeneraterequest_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmLoadSession cdm_loadsession_rpc = 503;
      case 503: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(186u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_loadsession_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmUpdateSession cdm_updatesession_rpc = 504;
      case 504: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_updatesession_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmCloseSession cdm_closesession_rpc = 505;
      case 505: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(202u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_closesession_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmRemoveSession cdm_removesession_rpc = 506;
      case 506: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(210u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_removesession_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmPromise cdm_promise_rpc = 600;
      case 600: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(194u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdm_promise_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmClientOnSessionMessage cdmclient_onsessionmessage_rpc = 601;
      case 601: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(202u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdmclient_onsessionmessage_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmClientOnSessionKeysChange cdmclient_onsessionkeychange_rpc = 602;
      case 602: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(210u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdmclient_onsessionkeychange_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .media.remoting.pb.CdmClientOnSessionExpirationUpdate cdmclient_onsessionexpirationupdate_rpc = 603;
      case 603: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(218u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_cdmclient_onsessionexpirationupdate_rpc()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:media.remoting.pb.RpcMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:media.remoting.pb.RpcMessage)
  return false;
#undef DO_
}

void RpcMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:media.remoting.pb.RpcMessage)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 handle = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->handle(), output);
  }

  // optional .media.remoting.pb.RpcMessage.RpcProc proc = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->proc(), output);
  }

  switch (rpc_oneof_case()) {
    case kIntegerValue:
      ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->integer_value(), output);
      break;
    case kInteger64Value:
      ::google::protobuf::internal::WireFormatLite::WriteInt64(4, this->integer64_value(), output);
      break;
    case kDoubleValue:
      ::google::protobuf::internal::WireFormatLite::WriteDouble(5, this->double_value(), output);
      break;
    case kBooleanValue:
      ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->boolean_value(), output);
      break;
    case kStringValue:
      ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
        7, this->string_value(), output);
      break;
    case kRendererInitializeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        100, *rpc_oneof_.renderer_initialize_rpc_, output);
      break;
    case kRendererFlushuntilRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        101, *rpc_oneof_.renderer_flushuntil_rpc_, output);
      break;
    case kRendererSetCdmRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        102, *rpc_oneof_.renderer_set_cdm_rpc_, output);
      break;
    case kRendererclientOntimeupdateRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        200, *rpc_oneof_.rendererclient_ontimeupdate_rpc_, output);
      break;
    case kRendererclientOnvideonatualsizechangeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        201, *rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_, output);
      break;
    case kRendererclientOnstatisticsupdateRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        202, *rpc_oneof_.rendererclient_onstatisticsupdate_rpc_, output);
      break;
    case kRendererclientOnbufferingstatechangeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        203, *rpc_oneof_.rendererclient_onbufferingstatechange_rpc_, output);
      break;
    case kRendererclientOnaudioconfigchangeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        204, *rpc_oneof_.rendererclient_onaudioconfigchange_rpc_, output);
      break;
    case kRendererclientOnvideoconfigchangeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        205, *rpc_oneof_.rendererclient_onvideoconfigchange_rpc_, output);
      break;
    case kDemuxerstreamReaduntilRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        300, *rpc_oneof_.demuxerstream_readuntil_rpc_, output);
      break;
    case kDemuxerstreamInitializecbRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        400, *rpc_oneof_.demuxerstream_initializecb_rpc_, output);
      break;
    case kDemuxerstreamReaduntilcbRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        401, *rpc_oneof_.demuxerstream_readuntilcb_rpc_, output);
      break;
    case kCdmInitializeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        500, *rpc_oneof_.cdm_initialize_rpc_, output);
      break;
    case kCdmSetservercertificateRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        501, *rpc_oneof_.cdm_setservercertificate_rpc_, output);
      break;
    case kCdmCreatesessionandgeneraterequestRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        502, *rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_, output);
      break;
    case kCdmLoadsessionRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        503, *rpc_oneof_.cdm_loadsession_rpc_, output);
      break;
    case kCdmUpdatesessionRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        504, *rpc_oneof_.cdm_updatesession_rpc_, output);
      break;
    case kCdmClosesessionRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        505, *rpc_oneof_.cdm_closesession_rpc_, output);
      break;
    case kCdmRemovesessionRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        506, *rpc_oneof_.cdm_removesession_rpc_, output);
      break;
    case kCdmPromiseRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        600, *rpc_oneof_.cdm_promise_rpc_, output);
      break;
    case kCdmclientOnsessionmessageRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        601, *rpc_oneof_.cdmclient_onsessionmessage_rpc_, output);
      break;
    case kCdmclientOnsessionkeychangeRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        602, *rpc_oneof_.cdmclient_onsessionkeychange_rpc_, output);
      break;
    case kCdmclientOnsessionexpirationupdateRpc:
      ::google::protobuf::internal::WireFormatLite::WriteMessage(
        603, *rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_, output);
      break;
    default: ;
  }
  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:media.remoting.pb.RpcMessage)
}

size_t RpcMessage::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:media.remoting.pb.RpcMessage)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional int32 handle = 1;
    if (has_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->handle());
    }

    // optional .media.remoting.pb.RpcMessage.RpcProc proc = 2;
    if (has_proc()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->proc());
    }

  }
  switch (rpc_oneof_case()) {
    // optional int32 integer_value = 3;
    case kIntegerValue: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->integer_value());
      break;
    }
    // optional int64 integer64_value = 4;
    case kInteger64Value: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->integer64_value());
      break;
    }
    // optional double double_value = 5;
    case kDoubleValue: {
      total_size += 1 + 8;
      break;
    }
    // optional bool boolean_value = 6;
    case kBooleanValue: {
      total_size += 1 + 1;
      break;
    }
    // optional string string_value = 7;
    case kStringValue: {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->string_value());
      break;
    }
    // optional .media.remoting.pb.RendererInitialize renderer_initialize_rpc = 100;
    case kRendererInitializeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.renderer_initialize_rpc_);
      break;
    }
    // optional .media.remoting.pb.RendererFlushUntil renderer_flushuntil_rpc = 101;
    case kRendererFlushuntilRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.renderer_flushuntil_rpc_);
      break;
    }
    // optional .media.remoting.pb.RendererSetCdm renderer_set_cdm_rpc = 102;
    case kRendererSetCdmRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.renderer_set_cdm_rpc_);
      break;
    }
    // optional .media.remoting.pb.RendererClientOnTimeUpdate rendererclient_ontimeupdate_rpc = 200;
    case kRendererclientOntimeupdateRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.rendererclient_ontimeupdate_rpc_);
      break;
    }
    // optional .media.remoting.pb.Size rendererclient_onvideonatualsizechange_rpc = 201;
    case kRendererclientOnvideonatualsizechangeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_);
      break;
    }
    // optional .media.remoting.pb.PipelineStatistics rendererclient_onstatisticsupdate_rpc = 202;
    case kRendererclientOnstatisticsupdateRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.rendererclient_onstatisticsupdate_rpc_);
      break;
    }
    // optional .media.remoting.pb.RendererClientOnBufferingStateChange rendererclient_onbufferingstatechange_rpc = 203;
    case kRendererclientOnbufferingstatechangeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.rendererclient_onbufferingstatechange_rpc_);
      break;
    }
    // optional .media.remoting.pb.RendererClientOnAudioConfigChange rendererclient_onaudioconfigchange_rpc = 204;
    case kRendererclientOnaudioconfigchangeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.rendererclient_onaudioconfigchange_rpc_);
      break;
    }
    // optional .media.remoting.pb.RendererClientOnVideoConfigChange rendererclient_onvideoconfigchange_rpc = 205;
    case kRendererclientOnvideoconfigchangeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.rendererclient_onvideoconfigchange_rpc_);
      break;
    }
    // optional .media.remoting.pb.DemuxerStreamReadUntil demuxerstream_readuntil_rpc = 300;
    case kDemuxerstreamReaduntilRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.demuxerstream_readuntil_rpc_);
      break;
    }
    // optional .media.remoting.pb.DemuxerStreamInitializeCallback demuxerstream_initializecb_rpc = 400;
    case kDemuxerstreamInitializecbRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.demuxerstream_initializecb_rpc_);
      break;
    }
    // optional .media.remoting.pb.DemuxerStreamReadUntilCallback demuxerstream_readuntilcb_rpc = 401;
    case kDemuxerstreamReaduntilcbRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.demuxerstream_readuntilcb_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmInitialize cdm_initialize_rpc = 500;
    case kCdmInitializeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_initialize_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmSetServerCertificate cdm_setservercertificate_rpc = 501;
    case kCdmSetservercertificateRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_setservercertificate_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest cdm_createsessionandgeneraterequest_rpc = 502;
    case kCdmCreatesessionandgeneraterequestRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmLoadSession cdm_loadsession_rpc = 503;
    case kCdmLoadsessionRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_loadsession_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmUpdateSession cdm_updatesession_rpc = 504;
    case kCdmUpdatesessionRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_updatesession_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmCloseSession cdm_closesession_rpc = 505;
    case kCdmClosesessionRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_closesession_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmRemoveSession cdm_removesession_rpc = 506;
    case kCdmRemovesessionRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_removesession_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmPromise cdm_promise_rpc = 600;
    case kCdmPromiseRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdm_promise_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmClientOnSessionMessage cdmclient_onsessionmessage_rpc = 601;
    case kCdmclientOnsessionmessageRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdmclient_onsessionmessage_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmClientOnSessionKeysChange cdmclient_onsessionkeychange_rpc = 602;
    case kCdmclientOnsessionkeychangeRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdmclient_onsessionkeychange_rpc_);
      break;
    }
    // optional .media.remoting.pb.CdmClientOnSessionExpirationUpdate cdmclient_onsessionexpirationupdate_rpc = 603;
    case kCdmclientOnsessionexpirationupdateRpc: {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_);
      break;
    }
    case RPC_ONEOF_NOT_SET: {
      break;
    }
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void RpcMessage::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const RpcMessage*>(&from));
}

void RpcMessage::MergeFrom(const RpcMessage& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:media.remoting.pb.RpcMessage)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      handle_ = from.handle_;
    }
    if (cached_has_bits & 0x00000002u) {
      proc_ = from.proc_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  switch (from.rpc_oneof_case()) {
    case kIntegerValue: {
      set_integer_value(from.integer_value());
      break;
    }
    case kInteger64Value: {
      set_integer64_value(from.integer64_value());
      break;
    }
    case kDoubleValue: {
      set_double_value(from.double_value());
      break;
    }
    case kBooleanValue: {
      set_boolean_value(from.boolean_value());
      break;
    }
    case kStringValue: {
      set_string_value(from.string_value());
      break;
    }
    case kRendererInitializeRpc: {
      mutable_renderer_initialize_rpc()->::media::remoting::pb::RendererInitialize::MergeFrom(from.renderer_initialize_rpc());
      break;
    }
    case kRendererFlushuntilRpc: {
      mutable_renderer_flushuntil_rpc()->::media::remoting::pb::RendererFlushUntil::MergeFrom(from.renderer_flushuntil_rpc());
      break;
    }
    case kRendererSetCdmRpc: {
      mutable_renderer_set_cdm_rpc()->::media::remoting::pb::RendererSetCdm::MergeFrom(from.renderer_set_cdm_rpc());
      break;
    }
    case kRendererclientOntimeupdateRpc: {
      mutable_rendererclient_ontimeupdate_rpc()->::media::remoting::pb::RendererClientOnTimeUpdate::MergeFrom(from.rendererclient_ontimeupdate_rpc());
      break;
    }
    case kRendererclientOnvideonatualsizechangeRpc: {
      mutable_rendererclient_onvideonatualsizechange_rpc()->::media::remoting::pb::Size::MergeFrom(from.rendererclient_onvideonatualsizechange_rpc());
      break;
    }
    case kRendererclientOnstatisticsupdateRpc: {
      mutable_rendererclient_onstatisticsupdate_rpc()->::media::remoting::pb::PipelineStatistics::MergeFrom(from.rendererclient_onstatisticsupdate_rpc());
      break;
    }
    case kRendererclientOnbufferingstatechangeRpc: {
      mutable_rendererclient_onbufferingstatechange_rpc()->::media::remoting::pb::RendererClientOnBufferingStateChange::MergeFrom(from.rendererclient_onbufferingstatechange_rpc());
      break;
    }
    case kRendererclientOnaudioconfigchangeRpc: {
      mutable_rendererclient_onaudioconfigchange_rpc()->::media::remoting::pb::RendererClientOnAudioConfigChange::MergeFrom(from.rendererclient_onaudioconfigchange_rpc());
      break;
    }
    case kRendererclientOnvideoconfigchangeRpc: {
      mutable_rendererclient_onvideoconfigchange_rpc()->::media::remoting::pb::RendererClientOnVideoConfigChange::MergeFrom(from.rendererclient_onvideoconfigchange_rpc());
      break;
    }
    case kDemuxerstreamReaduntilRpc: {
      mutable_demuxerstream_readuntil_rpc()->::media::remoting::pb::DemuxerStreamReadUntil::MergeFrom(from.demuxerstream_readuntil_rpc());
      break;
    }
    case kDemuxerstreamInitializecbRpc: {
      mutable_demuxerstream_initializecb_rpc()->::media::remoting::pb::DemuxerStreamInitializeCallback::MergeFrom(from.demuxerstream_initializecb_rpc());
      break;
    }
    case kDemuxerstreamReaduntilcbRpc: {
      mutable_demuxerstream_readuntilcb_rpc()->::media::remoting::pb::DemuxerStreamReadUntilCallback::MergeFrom(from.demuxerstream_readuntilcb_rpc());
      break;
    }
    case kCdmInitializeRpc: {
      mutable_cdm_initialize_rpc()->::media::remoting::pb::CdmInitialize::MergeFrom(from.cdm_initialize_rpc());
      break;
    }
    case kCdmSetservercertificateRpc: {
      mutable_cdm_setservercertificate_rpc()->::media::remoting::pb::CdmSetServerCertificate::MergeFrom(from.cdm_setservercertificate_rpc());
      break;
    }
    case kCdmCreatesessionandgeneraterequestRpc: {
      mutable_cdm_createsessionandgeneraterequest_rpc()->::media::remoting::pb::CdmCreateSessionAndGenerateRequest::MergeFrom(from.cdm_createsessionandgeneraterequest_rpc());
      break;
    }
    case kCdmLoadsessionRpc: {
      mutable_cdm_loadsession_rpc()->::media::remoting::pb::CdmLoadSession::MergeFrom(from.cdm_loadsession_rpc());
      break;
    }
    case kCdmUpdatesessionRpc: {
      mutable_cdm_updatesession_rpc()->::media::remoting::pb::CdmUpdateSession::MergeFrom(from.cdm_updatesession_rpc());
      break;
    }
    case kCdmClosesessionRpc: {
      mutable_cdm_closesession_rpc()->::media::remoting::pb::CdmCloseSession::MergeFrom(from.cdm_closesession_rpc());
      break;
    }
    case kCdmRemovesessionRpc: {
      mutable_cdm_removesession_rpc()->::media::remoting::pb::CdmRemoveSession::MergeFrom(from.cdm_removesession_rpc());
      break;
    }
    case kCdmPromiseRpc: {
      mutable_cdm_promise_rpc()->::media::remoting::pb::CdmPromise::MergeFrom(from.cdm_promise_rpc());
      break;
    }
    case kCdmclientOnsessionmessageRpc: {
      mutable_cdmclient_onsessionmessage_rpc()->::media::remoting::pb::CdmClientOnSessionMessage::MergeFrom(from.cdmclient_onsessionmessage_rpc());
      break;
    }
    case kCdmclientOnsessionkeychangeRpc: {
      mutable_cdmclient_onsessionkeychange_rpc()->::media::remoting::pb::CdmClientOnSessionKeysChange::MergeFrom(from.cdmclient_onsessionkeychange_rpc());
      break;
    }
    case kCdmclientOnsessionexpirationupdateRpc: {
      mutable_cdmclient_onsessionexpirationupdate_rpc()->::media::remoting::pb::CdmClientOnSessionExpirationUpdate::MergeFrom(from.cdmclient_onsessionexpirationupdate_rpc());
      break;
    }
    case RPC_ONEOF_NOT_SET: {
      break;
    }
  }
}

void RpcMessage::CopyFrom(const RpcMessage& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:media.remoting.pb.RpcMessage)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RpcMessage::IsInitialized() const {
  return true;
}

void RpcMessage::Swap(RpcMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void RpcMessage::InternalSwap(RpcMessage* other) {
  std::swap(handle_, other->handle_);
  std::swap(proc_, other->proc_);
  std::swap(rpc_oneof_, other->rpc_oneof_);
  std::swap(_oneof_case_[0], other->_oneof_case_[0]);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string RpcMessage::GetTypeName() const {
  return "media.remoting.pb.RpcMessage";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// RpcMessage

// optional int32 handle = 1;
bool RpcMessage::has_handle() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void RpcMessage::set_has_handle() {
  _has_bits_[0] |= 0x00000001u;
}
void RpcMessage::clear_has_handle() {
  _has_bits_[0] &= ~0x00000001u;
}
void RpcMessage::clear_handle() {
  handle_ = 0;
  clear_has_handle();
}
::google::protobuf::int32 RpcMessage::handle() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.handle)
  return handle_;
}
void RpcMessage::set_handle(::google::protobuf::int32 value) {
  set_has_handle();
  handle_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.handle)
}

// optional .media.remoting.pb.RpcMessage.RpcProc proc = 2;
bool RpcMessage::has_proc() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void RpcMessage::set_has_proc() {
  _has_bits_[0] |= 0x00000002u;
}
void RpcMessage::clear_has_proc() {
  _has_bits_[0] &= ~0x00000002u;
}
void RpcMessage::clear_proc() {
  proc_ = 0;
  clear_has_proc();
}
::media::remoting::pb::RpcMessage_RpcProc RpcMessage::proc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.proc)
  return static_cast< ::media::remoting::pb::RpcMessage_RpcProc >(proc_);
}
void RpcMessage::set_proc(::media::remoting::pb::RpcMessage_RpcProc value) {
  assert(::media::remoting::pb::RpcMessage_RpcProc_IsValid(value));
  set_has_proc();
  proc_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.proc)
}

// optional int32 integer_value = 3;
bool RpcMessage::has_integer_value() const {
  return rpc_oneof_case() == kIntegerValue;
}
void RpcMessage::set_has_integer_value() {
  _oneof_case_[0] = kIntegerValue;
}
void RpcMessage::clear_integer_value() {
  if (has_integer_value()) {
    rpc_oneof_.integer_value_ = 0;
    clear_has_rpc_oneof();
  }
}
::google::protobuf::int32 RpcMessage::integer_value() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.integer_value)
  if (has_integer_value()) {
    return rpc_oneof_.integer_value_;
  }
  return 0;
}
void RpcMessage::set_integer_value(::google::protobuf::int32 value) {
  if (!has_integer_value()) {
    clear_rpc_oneof();
    set_has_integer_value();
  }
  rpc_oneof_.integer_value_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.integer_value)
}

// optional int64 integer64_value = 4;
bool RpcMessage::has_integer64_value() const {
  return rpc_oneof_case() == kInteger64Value;
}
void RpcMessage::set_has_integer64_value() {
  _oneof_case_[0] = kInteger64Value;
}
void RpcMessage::clear_integer64_value() {
  if (has_integer64_value()) {
    rpc_oneof_.integer64_value_ = GOOGLE_LONGLONG(0);
    clear_has_rpc_oneof();
  }
}
::google::protobuf::int64 RpcMessage::integer64_value() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.integer64_value)
  if (has_integer64_value()) {
    return rpc_oneof_.integer64_value_;
  }
  return GOOGLE_LONGLONG(0);
}
void RpcMessage::set_integer64_value(::google::protobuf::int64 value) {
  if (!has_integer64_value()) {
    clear_rpc_oneof();
    set_has_integer64_value();
  }
  rpc_oneof_.integer64_value_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.integer64_value)
}

// optional double double_value = 5;
bool RpcMessage::has_double_value() const {
  return rpc_oneof_case() == kDoubleValue;
}
void RpcMessage::set_has_double_value() {
  _oneof_case_[0] = kDoubleValue;
}
void RpcMessage::clear_double_value() {
  if (has_double_value()) {
    rpc_oneof_.double_value_ = 0;
    clear_has_rpc_oneof();
  }
}
double RpcMessage::double_value() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.double_value)
  if (has_double_value()) {
    return rpc_oneof_.double_value_;
  }
  return 0;
}
void RpcMessage::set_double_value(double value) {
  if (!has_double_value()) {
    clear_rpc_oneof();
    set_has_double_value();
  }
  rpc_oneof_.double_value_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.double_value)
}

// optional bool boolean_value = 6;
bool RpcMessage::has_boolean_value() const {
  return rpc_oneof_case() == kBooleanValue;
}
void RpcMessage::set_has_boolean_value() {
  _oneof_case_[0] = kBooleanValue;
}
void RpcMessage::clear_boolean_value() {
  if (has_boolean_value()) {
    rpc_oneof_.boolean_value_ = false;
    clear_has_rpc_oneof();
  }
}
bool RpcMessage::boolean_value() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.boolean_value)
  if (has_boolean_value()) {
    return rpc_oneof_.boolean_value_;
  }
  return false;
}
void RpcMessage::set_boolean_value(bool value) {
  if (!has_boolean_value()) {
    clear_rpc_oneof();
    set_has_boolean_value();
  }
  rpc_oneof_.boolean_value_ = value;
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.boolean_value)
}

// optional string string_value = 7;
bool RpcMessage::has_string_value() const {
  return rpc_oneof_case() == kStringValue;
}
void RpcMessage::set_has_string_value() {
  _oneof_case_[0] = kStringValue;
}
void RpcMessage::clear_string_value() {
  if (has_string_value()) {
    rpc_oneof_.string_value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_rpc_oneof();
  }
}
const ::std::string& RpcMessage::string_value() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.string_value)
  if (has_string_value()) {
    return rpc_oneof_.string_value_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
void RpcMessage::set_string_value(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.string_value)
  if (!has_string_value()) {
    clear_rpc_oneof();
    set_has_string_value();
    rpc_oneof_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rpc_oneof_.string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.string_value)
}
#if LANG_CXX11
void RpcMessage::set_string_value(::std::string&& value) {
  // @@protoc_insertion_point(field_set:media.remoting.pb.RpcMessage.string_value)
  if (!has_string_value()) {
    clear_rpc_oneof();
    set_has_string_value();
    rpc_oneof_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rpc_oneof_.string_value_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:media.remoting.pb.RpcMessage.string_value)
}
#endif
void RpcMessage::set_string_value(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_string_value()) {
    clear_rpc_oneof();
    set_has_string_value();
    rpc_oneof_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rpc_oneof_.string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:media.remoting.pb.RpcMessage.string_value)
}
void RpcMessage::set_string_value(const char* value, size_t size) {
  if (!has_string_value()) {
    clear_rpc_oneof();
    set_has_string_value();
    rpc_oneof_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  rpc_oneof_.string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:media.remoting.pb.RpcMessage.string_value)
}
::std::string* RpcMessage::mutable_string_value() {
  if (!has_string_value()) {
    clear_rpc_oneof();
    set_has_string_value();
    rpc_oneof_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.string_value)
  return rpc_oneof_.string_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* RpcMessage::release_string_value() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.string_value)
  if (has_string_value()) {
    clear_has_rpc_oneof();
    return rpc_oneof_.string_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_string_value(::std::string* string_value) {
  if (!has_string_value()) {
    rpc_oneof_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_rpc_oneof();
  if (string_value != NULL) {
    set_has_string_value();
    rpc_oneof_.string_value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        string_value);
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.string_value)
}

// optional .media.remoting.pb.RendererInitialize renderer_initialize_rpc = 100;
bool RpcMessage::has_renderer_initialize_rpc() const {
  return rpc_oneof_case() == kRendererInitializeRpc;
}
void RpcMessage::set_has_renderer_initialize_rpc() {
  _oneof_case_[0] = kRendererInitializeRpc;
}
void RpcMessage::clear_renderer_initialize_rpc() {
  if (has_renderer_initialize_rpc()) {
    delete rpc_oneof_.renderer_initialize_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererInitialize& RpcMessage::renderer_initialize_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.renderer_initialize_rpc)
  return has_renderer_initialize_rpc()
      ? *rpc_oneof_.renderer_initialize_rpc_
      : ::media::remoting::pb::RendererInitialize::default_instance();
}
::media::remoting::pb::RendererInitialize* RpcMessage::mutable_renderer_initialize_rpc() {
  if (!has_renderer_initialize_rpc()) {
    clear_rpc_oneof();
    set_has_renderer_initialize_rpc();
    rpc_oneof_.renderer_initialize_rpc_ = new ::media::remoting::pb::RendererInitialize;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.renderer_initialize_rpc)
  return rpc_oneof_.renderer_initialize_rpc_;
}
::media::remoting::pb::RendererInitialize* RpcMessage::release_renderer_initialize_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.renderer_initialize_rpc)
  if (has_renderer_initialize_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererInitialize* temp = rpc_oneof_.renderer_initialize_rpc_;
    rpc_oneof_.renderer_initialize_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_renderer_initialize_rpc(::media::remoting::pb::RendererInitialize* renderer_initialize_rpc) {
  clear_rpc_oneof();
  if (renderer_initialize_rpc) {
    set_has_renderer_initialize_rpc();
    rpc_oneof_.renderer_initialize_rpc_ = renderer_initialize_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.renderer_initialize_rpc)
}

// optional .media.remoting.pb.RendererFlushUntil renderer_flushuntil_rpc = 101;
bool RpcMessage::has_renderer_flushuntil_rpc() const {
  return rpc_oneof_case() == kRendererFlushuntilRpc;
}
void RpcMessage::set_has_renderer_flushuntil_rpc() {
  _oneof_case_[0] = kRendererFlushuntilRpc;
}
void RpcMessage::clear_renderer_flushuntil_rpc() {
  if (has_renderer_flushuntil_rpc()) {
    delete rpc_oneof_.renderer_flushuntil_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererFlushUntil& RpcMessage::renderer_flushuntil_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.renderer_flushuntil_rpc)
  return has_renderer_flushuntil_rpc()
      ? *rpc_oneof_.renderer_flushuntil_rpc_
      : ::media::remoting::pb::RendererFlushUntil::default_instance();
}
::media::remoting::pb::RendererFlushUntil* RpcMessage::mutable_renderer_flushuntil_rpc() {
  if (!has_renderer_flushuntil_rpc()) {
    clear_rpc_oneof();
    set_has_renderer_flushuntil_rpc();
    rpc_oneof_.renderer_flushuntil_rpc_ = new ::media::remoting::pb::RendererFlushUntil;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.renderer_flushuntil_rpc)
  return rpc_oneof_.renderer_flushuntil_rpc_;
}
::media::remoting::pb::RendererFlushUntil* RpcMessage::release_renderer_flushuntil_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.renderer_flushuntil_rpc)
  if (has_renderer_flushuntil_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererFlushUntil* temp = rpc_oneof_.renderer_flushuntil_rpc_;
    rpc_oneof_.renderer_flushuntil_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_renderer_flushuntil_rpc(::media::remoting::pb::RendererFlushUntil* renderer_flushuntil_rpc) {
  clear_rpc_oneof();
  if (renderer_flushuntil_rpc) {
    set_has_renderer_flushuntil_rpc();
    rpc_oneof_.renderer_flushuntil_rpc_ = renderer_flushuntil_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.renderer_flushuntil_rpc)
}

// optional .media.remoting.pb.RendererSetCdm renderer_set_cdm_rpc = 102;
bool RpcMessage::has_renderer_set_cdm_rpc() const {
  return rpc_oneof_case() == kRendererSetCdmRpc;
}
void RpcMessage::set_has_renderer_set_cdm_rpc() {
  _oneof_case_[0] = kRendererSetCdmRpc;
}
void RpcMessage::clear_renderer_set_cdm_rpc() {
  if (has_renderer_set_cdm_rpc()) {
    delete rpc_oneof_.renderer_set_cdm_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererSetCdm& RpcMessage::renderer_set_cdm_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.renderer_set_cdm_rpc)
  return has_renderer_set_cdm_rpc()
      ? *rpc_oneof_.renderer_set_cdm_rpc_
      : ::media::remoting::pb::RendererSetCdm::default_instance();
}
::media::remoting::pb::RendererSetCdm* RpcMessage::mutable_renderer_set_cdm_rpc() {
  if (!has_renderer_set_cdm_rpc()) {
    clear_rpc_oneof();
    set_has_renderer_set_cdm_rpc();
    rpc_oneof_.renderer_set_cdm_rpc_ = new ::media::remoting::pb::RendererSetCdm;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.renderer_set_cdm_rpc)
  return rpc_oneof_.renderer_set_cdm_rpc_;
}
::media::remoting::pb::RendererSetCdm* RpcMessage::release_renderer_set_cdm_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.renderer_set_cdm_rpc)
  if (has_renderer_set_cdm_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererSetCdm* temp = rpc_oneof_.renderer_set_cdm_rpc_;
    rpc_oneof_.renderer_set_cdm_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_renderer_set_cdm_rpc(::media::remoting::pb::RendererSetCdm* renderer_set_cdm_rpc) {
  clear_rpc_oneof();
  if (renderer_set_cdm_rpc) {
    set_has_renderer_set_cdm_rpc();
    rpc_oneof_.renderer_set_cdm_rpc_ = renderer_set_cdm_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.renderer_set_cdm_rpc)
}

// optional .media.remoting.pb.RendererClientOnTimeUpdate rendererclient_ontimeupdate_rpc = 200;
bool RpcMessage::has_rendererclient_ontimeupdate_rpc() const {
  return rpc_oneof_case() == kRendererclientOntimeupdateRpc;
}
void RpcMessage::set_has_rendererclient_ontimeupdate_rpc() {
  _oneof_case_[0] = kRendererclientOntimeupdateRpc;
}
void RpcMessage::clear_rendererclient_ontimeupdate_rpc() {
  if (has_rendererclient_ontimeupdate_rpc()) {
    delete rpc_oneof_.rendererclient_ontimeupdate_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererClientOnTimeUpdate& RpcMessage::rendererclient_ontimeupdate_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.rendererclient_ontimeupdate_rpc)
  return has_rendererclient_ontimeupdate_rpc()
      ? *rpc_oneof_.rendererclient_ontimeupdate_rpc_
      : ::media::remoting::pb::RendererClientOnTimeUpdate::default_instance();
}
::media::remoting::pb::RendererClientOnTimeUpdate* RpcMessage::mutable_rendererclient_ontimeupdate_rpc() {
  if (!has_rendererclient_ontimeupdate_rpc()) {
    clear_rpc_oneof();
    set_has_rendererclient_ontimeupdate_rpc();
    rpc_oneof_.rendererclient_ontimeupdate_rpc_ = new ::media::remoting::pb::RendererClientOnTimeUpdate;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.rendererclient_ontimeupdate_rpc)
  return rpc_oneof_.rendererclient_ontimeupdate_rpc_;
}
::media::remoting::pb::RendererClientOnTimeUpdate* RpcMessage::release_rendererclient_ontimeupdate_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.rendererclient_ontimeupdate_rpc)
  if (has_rendererclient_ontimeupdate_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererClientOnTimeUpdate* temp = rpc_oneof_.rendererclient_ontimeupdate_rpc_;
    rpc_oneof_.rendererclient_ontimeupdate_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_rendererclient_ontimeupdate_rpc(::media::remoting::pb::RendererClientOnTimeUpdate* rendererclient_ontimeupdate_rpc) {
  clear_rpc_oneof();
  if (rendererclient_ontimeupdate_rpc) {
    set_has_rendererclient_ontimeupdate_rpc();
    rpc_oneof_.rendererclient_ontimeupdate_rpc_ = rendererclient_ontimeupdate_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.rendererclient_ontimeupdate_rpc)
}

// optional .media.remoting.pb.Size rendererclient_onvideonatualsizechange_rpc = 201;
bool RpcMessage::has_rendererclient_onvideonatualsizechange_rpc() const {
  return rpc_oneof_case() == kRendererclientOnvideonatualsizechangeRpc;
}
void RpcMessage::set_has_rendererclient_onvideonatualsizechange_rpc() {
  _oneof_case_[0] = kRendererclientOnvideonatualsizechangeRpc;
}
void RpcMessage::clear_rendererclient_onvideonatualsizechange_rpc() {
  if (has_rendererclient_onvideonatualsizechange_rpc()) {
    delete rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::Size& RpcMessage::rendererclient_onvideonatualsizechange_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.rendererclient_onvideonatualsizechange_rpc)
  return has_rendererclient_onvideonatualsizechange_rpc()
      ? *rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_
      : ::media::remoting::pb::Size::default_instance();
}
::media::remoting::pb::Size* RpcMessage::mutable_rendererclient_onvideonatualsizechange_rpc() {
  if (!has_rendererclient_onvideonatualsizechange_rpc()) {
    clear_rpc_oneof();
    set_has_rendererclient_onvideonatualsizechange_rpc();
    rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_ = new ::media::remoting::pb::Size;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.rendererclient_onvideonatualsizechange_rpc)
  return rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_;
}
::media::remoting::pb::Size* RpcMessage::release_rendererclient_onvideonatualsizechange_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.rendererclient_onvideonatualsizechange_rpc)
  if (has_rendererclient_onvideonatualsizechange_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::Size* temp = rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_;
    rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_rendererclient_onvideonatualsizechange_rpc(::media::remoting::pb::Size* rendererclient_onvideonatualsizechange_rpc) {
  clear_rpc_oneof();
  if (rendererclient_onvideonatualsizechange_rpc) {
    set_has_rendererclient_onvideonatualsizechange_rpc();
    rpc_oneof_.rendererclient_onvideonatualsizechange_rpc_ = rendererclient_onvideonatualsizechange_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.rendererclient_onvideonatualsizechange_rpc)
}

// optional .media.remoting.pb.PipelineStatistics rendererclient_onstatisticsupdate_rpc = 202;
bool RpcMessage::has_rendererclient_onstatisticsupdate_rpc() const {
  return rpc_oneof_case() == kRendererclientOnstatisticsupdateRpc;
}
void RpcMessage::set_has_rendererclient_onstatisticsupdate_rpc() {
  _oneof_case_[0] = kRendererclientOnstatisticsupdateRpc;
}
void RpcMessage::clear_rendererclient_onstatisticsupdate_rpc() {
  if (has_rendererclient_onstatisticsupdate_rpc()) {
    delete rpc_oneof_.rendererclient_onstatisticsupdate_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::PipelineStatistics& RpcMessage::rendererclient_onstatisticsupdate_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.rendererclient_onstatisticsupdate_rpc)
  return has_rendererclient_onstatisticsupdate_rpc()
      ? *rpc_oneof_.rendererclient_onstatisticsupdate_rpc_
      : ::media::remoting::pb::PipelineStatistics::default_instance();
}
::media::remoting::pb::PipelineStatistics* RpcMessage::mutable_rendererclient_onstatisticsupdate_rpc() {
  if (!has_rendererclient_onstatisticsupdate_rpc()) {
    clear_rpc_oneof();
    set_has_rendererclient_onstatisticsupdate_rpc();
    rpc_oneof_.rendererclient_onstatisticsupdate_rpc_ = new ::media::remoting::pb::PipelineStatistics;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.rendererclient_onstatisticsupdate_rpc)
  return rpc_oneof_.rendererclient_onstatisticsupdate_rpc_;
}
::media::remoting::pb::PipelineStatistics* RpcMessage::release_rendererclient_onstatisticsupdate_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.rendererclient_onstatisticsupdate_rpc)
  if (has_rendererclient_onstatisticsupdate_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::PipelineStatistics* temp = rpc_oneof_.rendererclient_onstatisticsupdate_rpc_;
    rpc_oneof_.rendererclient_onstatisticsupdate_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_rendererclient_onstatisticsupdate_rpc(::media::remoting::pb::PipelineStatistics* rendererclient_onstatisticsupdate_rpc) {
  clear_rpc_oneof();
  if (rendererclient_onstatisticsupdate_rpc) {
    set_has_rendererclient_onstatisticsupdate_rpc();
    rpc_oneof_.rendererclient_onstatisticsupdate_rpc_ = rendererclient_onstatisticsupdate_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.rendererclient_onstatisticsupdate_rpc)
}

// optional .media.remoting.pb.RendererClientOnBufferingStateChange rendererclient_onbufferingstatechange_rpc = 203;
bool RpcMessage::has_rendererclient_onbufferingstatechange_rpc() const {
  return rpc_oneof_case() == kRendererclientOnbufferingstatechangeRpc;
}
void RpcMessage::set_has_rendererclient_onbufferingstatechange_rpc() {
  _oneof_case_[0] = kRendererclientOnbufferingstatechangeRpc;
}
void RpcMessage::clear_rendererclient_onbufferingstatechange_rpc() {
  if (has_rendererclient_onbufferingstatechange_rpc()) {
    delete rpc_oneof_.rendererclient_onbufferingstatechange_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererClientOnBufferingStateChange& RpcMessage::rendererclient_onbufferingstatechange_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.rendererclient_onbufferingstatechange_rpc)
  return has_rendererclient_onbufferingstatechange_rpc()
      ? *rpc_oneof_.rendererclient_onbufferingstatechange_rpc_
      : ::media::remoting::pb::RendererClientOnBufferingStateChange::default_instance();
}
::media::remoting::pb::RendererClientOnBufferingStateChange* RpcMessage::mutable_rendererclient_onbufferingstatechange_rpc() {
  if (!has_rendererclient_onbufferingstatechange_rpc()) {
    clear_rpc_oneof();
    set_has_rendererclient_onbufferingstatechange_rpc();
    rpc_oneof_.rendererclient_onbufferingstatechange_rpc_ = new ::media::remoting::pb::RendererClientOnBufferingStateChange;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.rendererclient_onbufferingstatechange_rpc)
  return rpc_oneof_.rendererclient_onbufferingstatechange_rpc_;
}
::media::remoting::pb::RendererClientOnBufferingStateChange* RpcMessage::release_rendererclient_onbufferingstatechange_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.rendererclient_onbufferingstatechange_rpc)
  if (has_rendererclient_onbufferingstatechange_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererClientOnBufferingStateChange* temp = rpc_oneof_.rendererclient_onbufferingstatechange_rpc_;
    rpc_oneof_.rendererclient_onbufferingstatechange_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_rendererclient_onbufferingstatechange_rpc(::media::remoting::pb::RendererClientOnBufferingStateChange* rendererclient_onbufferingstatechange_rpc) {
  clear_rpc_oneof();
  if (rendererclient_onbufferingstatechange_rpc) {
    set_has_rendererclient_onbufferingstatechange_rpc();
    rpc_oneof_.rendererclient_onbufferingstatechange_rpc_ = rendererclient_onbufferingstatechange_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.rendererclient_onbufferingstatechange_rpc)
}

// optional .media.remoting.pb.RendererClientOnAudioConfigChange rendererclient_onaudioconfigchange_rpc = 204;
bool RpcMessage::has_rendererclient_onaudioconfigchange_rpc() const {
  return rpc_oneof_case() == kRendererclientOnaudioconfigchangeRpc;
}
void RpcMessage::set_has_rendererclient_onaudioconfigchange_rpc() {
  _oneof_case_[0] = kRendererclientOnaudioconfigchangeRpc;
}
void RpcMessage::clear_rendererclient_onaudioconfigchange_rpc() {
  if (has_rendererclient_onaudioconfigchange_rpc()) {
    delete rpc_oneof_.rendererclient_onaudioconfigchange_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererClientOnAudioConfigChange& RpcMessage::rendererclient_onaudioconfigchange_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.rendererclient_onaudioconfigchange_rpc)
  return has_rendererclient_onaudioconfigchange_rpc()
      ? *rpc_oneof_.rendererclient_onaudioconfigchange_rpc_
      : ::media::remoting::pb::RendererClientOnAudioConfigChange::default_instance();
}
::media::remoting::pb::RendererClientOnAudioConfigChange* RpcMessage::mutable_rendererclient_onaudioconfigchange_rpc() {
  if (!has_rendererclient_onaudioconfigchange_rpc()) {
    clear_rpc_oneof();
    set_has_rendererclient_onaudioconfigchange_rpc();
    rpc_oneof_.rendererclient_onaudioconfigchange_rpc_ = new ::media::remoting::pb::RendererClientOnAudioConfigChange;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.rendererclient_onaudioconfigchange_rpc)
  return rpc_oneof_.rendererclient_onaudioconfigchange_rpc_;
}
::media::remoting::pb::RendererClientOnAudioConfigChange* RpcMessage::release_rendererclient_onaudioconfigchange_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.rendererclient_onaudioconfigchange_rpc)
  if (has_rendererclient_onaudioconfigchange_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererClientOnAudioConfigChange* temp = rpc_oneof_.rendererclient_onaudioconfigchange_rpc_;
    rpc_oneof_.rendererclient_onaudioconfigchange_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_rendererclient_onaudioconfigchange_rpc(::media::remoting::pb::RendererClientOnAudioConfigChange* rendererclient_onaudioconfigchange_rpc) {
  clear_rpc_oneof();
  if (rendererclient_onaudioconfigchange_rpc) {
    set_has_rendererclient_onaudioconfigchange_rpc();
    rpc_oneof_.rendererclient_onaudioconfigchange_rpc_ = rendererclient_onaudioconfigchange_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.rendererclient_onaudioconfigchange_rpc)
}

// optional .media.remoting.pb.RendererClientOnVideoConfigChange rendererclient_onvideoconfigchange_rpc = 205;
bool RpcMessage::has_rendererclient_onvideoconfigchange_rpc() const {
  return rpc_oneof_case() == kRendererclientOnvideoconfigchangeRpc;
}
void RpcMessage::set_has_rendererclient_onvideoconfigchange_rpc() {
  _oneof_case_[0] = kRendererclientOnvideoconfigchangeRpc;
}
void RpcMessage::clear_rendererclient_onvideoconfigchange_rpc() {
  if (has_rendererclient_onvideoconfigchange_rpc()) {
    delete rpc_oneof_.rendererclient_onvideoconfigchange_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::RendererClientOnVideoConfigChange& RpcMessage::rendererclient_onvideoconfigchange_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.rendererclient_onvideoconfigchange_rpc)
  return has_rendererclient_onvideoconfigchange_rpc()
      ? *rpc_oneof_.rendererclient_onvideoconfigchange_rpc_
      : ::media::remoting::pb::RendererClientOnVideoConfigChange::default_instance();
}
::media::remoting::pb::RendererClientOnVideoConfigChange* RpcMessage::mutable_rendererclient_onvideoconfigchange_rpc() {
  if (!has_rendererclient_onvideoconfigchange_rpc()) {
    clear_rpc_oneof();
    set_has_rendererclient_onvideoconfigchange_rpc();
    rpc_oneof_.rendererclient_onvideoconfigchange_rpc_ = new ::media::remoting::pb::RendererClientOnVideoConfigChange;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.rendererclient_onvideoconfigchange_rpc)
  return rpc_oneof_.rendererclient_onvideoconfigchange_rpc_;
}
::media::remoting::pb::RendererClientOnVideoConfigChange* RpcMessage::release_rendererclient_onvideoconfigchange_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.rendererclient_onvideoconfigchange_rpc)
  if (has_rendererclient_onvideoconfigchange_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::RendererClientOnVideoConfigChange* temp = rpc_oneof_.rendererclient_onvideoconfigchange_rpc_;
    rpc_oneof_.rendererclient_onvideoconfigchange_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_rendererclient_onvideoconfigchange_rpc(::media::remoting::pb::RendererClientOnVideoConfigChange* rendererclient_onvideoconfigchange_rpc) {
  clear_rpc_oneof();
  if (rendererclient_onvideoconfigchange_rpc) {
    set_has_rendererclient_onvideoconfigchange_rpc();
    rpc_oneof_.rendererclient_onvideoconfigchange_rpc_ = rendererclient_onvideoconfigchange_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.rendererclient_onvideoconfigchange_rpc)
}

// optional .media.remoting.pb.DemuxerStreamReadUntil demuxerstream_readuntil_rpc = 300;
bool RpcMessage::has_demuxerstream_readuntil_rpc() const {
  return rpc_oneof_case() == kDemuxerstreamReaduntilRpc;
}
void RpcMessage::set_has_demuxerstream_readuntil_rpc() {
  _oneof_case_[0] = kDemuxerstreamReaduntilRpc;
}
void RpcMessage::clear_demuxerstream_readuntil_rpc() {
  if (has_demuxerstream_readuntil_rpc()) {
    delete rpc_oneof_.demuxerstream_readuntil_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::DemuxerStreamReadUntil& RpcMessage::demuxerstream_readuntil_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.demuxerstream_readuntil_rpc)
  return has_demuxerstream_readuntil_rpc()
      ? *rpc_oneof_.demuxerstream_readuntil_rpc_
      : ::media::remoting::pb::DemuxerStreamReadUntil::default_instance();
}
::media::remoting::pb::DemuxerStreamReadUntil* RpcMessage::mutable_demuxerstream_readuntil_rpc() {
  if (!has_demuxerstream_readuntil_rpc()) {
    clear_rpc_oneof();
    set_has_demuxerstream_readuntil_rpc();
    rpc_oneof_.demuxerstream_readuntil_rpc_ = new ::media::remoting::pb::DemuxerStreamReadUntil;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.demuxerstream_readuntil_rpc)
  return rpc_oneof_.demuxerstream_readuntil_rpc_;
}
::media::remoting::pb::DemuxerStreamReadUntil* RpcMessage::release_demuxerstream_readuntil_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.demuxerstream_readuntil_rpc)
  if (has_demuxerstream_readuntil_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::DemuxerStreamReadUntil* temp = rpc_oneof_.demuxerstream_readuntil_rpc_;
    rpc_oneof_.demuxerstream_readuntil_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_demuxerstream_readuntil_rpc(::media::remoting::pb::DemuxerStreamReadUntil* demuxerstream_readuntil_rpc) {
  clear_rpc_oneof();
  if (demuxerstream_readuntil_rpc) {
    set_has_demuxerstream_readuntil_rpc();
    rpc_oneof_.demuxerstream_readuntil_rpc_ = demuxerstream_readuntil_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.demuxerstream_readuntil_rpc)
}

// optional .media.remoting.pb.DemuxerStreamInitializeCallback demuxerstream_initializecb_rpc = 400;
bool RpcMessage::has_demuxerstream_initializecb_rpc() const {
  return rpc_oneof_case() == kDemuxerstreamInitializecbRpc;
}
void RpcMessage::set_has_demuxerstream_initializecb_rpc() {
  _oneof_case_[0] = kDemuxerstreamInitializecbRpc;
}
void RpcMessage::clear_demuxerstream_initializecb_rpc() {
  if (has_demuxerstream_initializecb_rpc()) {
    delete rpc_oneof_.demuxerstream_initializecb_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::DemuxerStreamInitializeCallback& RpcMessage::demuxerstream_initializecb_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.demuxerstream_initializecb_rpc)
  return has_demuxerstream_initializecb_rpc()
      ? *rpc_oneof_.demuxerstream_initializecb_rpc_
      : ::media::remoting::pb::DemuxerStreamInitializeCallback::default_instance();
}
::media::remoting::pb::DemuxerStreamInitializeCallback* RpcMessage::mutable_demuxerstream_initializecb_rpc() {
  if (!has_demuxerstream_initializecb_rpc()) {
    clear_rpc_oneof();
    set_has_demuxerstream_initializecb_rpc();
    rpc_oneof_.demuxerstream_initializecb_rpc_ = new ::media::remoting::pb::DemuxerStreamInitializeCallback;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.demuxerstream_initializecb_rpc)
  return rpc_oneof_.demuxerstream_initializecb_rpc_;
}
::media::remoting::pb::DemuxerStreamInitializeCallback* RpcMessage::release_demuxerstream_initializecb_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.demuxerstream_initializecb_rpc)
  if (has_demuxerstream_initializecb_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::DemuxerStreamInitializeCallback* temp = rpc_oneof_.demuxerstream_initializecb_rpc_;
    rpc_oneof_.demuxerstream_initializecb_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_demuxerstream_initializecb_rpc(::media::remoting::pb::DemuxerStreamInitializeCallback* demuxerstream_initializecb_rpc) {
  clear_rpc_oneof();
  if (demuxerstream_initializecb_rpc) {
    set_has_demuxerstream_initializecb_rpc();
    rpc_oneof_.demuxerstream_initializecb_rpc_ = demuxerstream_initializecb_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.demuxerstream_initializecb_rpc)
}

// optional .media.remoting.pb.DemuxerStreamReadUntilCallback demuxerstream_readuntilcb_rpc = 401;
bool RpcMessage::has_demuxerstream_readuntilcb_rpc() const {
  return rpc_oneof_case() == kDemuxerstreamReaduntilcbRpc;
}
void RpcMessage::set_has_demuxerstream_readuntilcb_rpc() {
  _oneof_case_[0] = kDemuxerstreamReaduntilcbRpc;
}
void RpcMessage::clear_demuxerstream_readuntilcb_rpc() {
  if (has_demuxerstream_readuntilcb_rpc()) {
    delete rpc_oneof_.demuxerstream_readuntilcb_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::DemuxerStreamReadUntilCallback& RpcMessage::demuxerstream_readuntilcb_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.demuxerstream_readuntilcb_rpc)
  return has_demuxerstream_readuntilcb_rpc()
      ? *rpc_oneof_.demuxerstream_readuntilcb_rpc_
      : ::media::remoting::pb::DemuxerStreamReadUntilCallback::default_instance();
}
::media::remoting::pb::DemuxerStreamReadUntilCallback* RpcMessage::mutable_demuxerstream_readuntilcb_rpc() {
  if (!has_demuxerstream_readuntilcb_rpc()) {
    clear_rpc_oneof();
    set_has_demuxerstream_readuntilcb_rpc();
    rpc_oneof_.demuxerstream_readuntilcb_rpc_ = new ::media::remoting::pb::DemuxerStreamReadUntilCallback;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.demuxerstream_readuntilcb_rpc)
  return rpc_oneof_.demuxerstream_readuntilcb_rpc_;
}
::media::remoting::pb::DemuxerStreamReadUntilCallback* RpcMessage::release_demuxerstream_readuntilcb_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.demuxerstream_readuntilcb_rpc)
  if (has_demuxerstream_readuntilcb_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::DemuxerStreamReadUntilCallback* temp = rpc_oneof_.demuxerstream_readuntilcb_rpc_;
    rpc_oneof_.demuxerstream_readuntilcb_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_demuxerstream_readuntilcb_rpc(::media::remoting::pb::DemuxerStreamReadUntilCallback* demuxerstream_readuntilcb_rpc) {
  clear_rpc_oneof();
  if (demuxerstream_readuntilcb_rpc) {
    set_has_demuxerstream_readuntilcb_rpc();
    rpc_oneof_.demuxerstream_readuntilcb_rpc_ = demuxerstream_readuntilcb_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.demuxerstream_readuntilcb_rpc)
}

// optional .media.remoting.pb.CdmInitialize cdm_initialize_rpc = 500;
bool RpcMessage::has_cdm_initialize_rpc() const {
  return rpc_oneof_case() == kCdmInitializeRpc;
}
void RpcMessage::set_has_cdm_initialize_rpc() {
  _oneof_case_[0] = kCdmInitializeRpc;
}
void RpcMessage::clear_cdm_initialize_rpc() {
  if (has_cdm_initialize_rpc()) {
    delete rpc_oneof_.cdm_initialize_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmInitialize& RpcMessage::cdm_initialize_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_initialize_rpc)
  return has_cdm_initialize_rpc()
      ? *rpc_oneof_.cdm_initialize_rpc_
      : ::media::remoting::pb::CdmInitialize::default_instance();
}
::media::remoting::pb::CdmInitialize* RpcMessage::mutable_cdm_initialize_rpc() {
  if (!has_cdm_initialize_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_initialize_rpc();
    rpc_oneof_.cdm_initialize_rpc_ = new ::media::remoting::pb::CdmInitialize;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_initialize_rpc)
  return rpc_oneof_.cdm_initialize_rpc_;
}
::media::remoting::pb::CdmInitialize* RpcMessage::release_cdm_initialize_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_initialize_rpc)
  if (has_cdm_initialize_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmInitialize* temp = rpc_oneof_.cdm_initialize_rpc_;
    rpc_oneof_.cdm_initialize_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_initialize_rpc(::media::remoting::pb::CdmInitialize* cdm_initialize_rpc) {
  clear_rpc_oneof();
  if (cdm_initialize_rpc) {
    set_has_cdm_initialize_rpc();
    rpc_oneof_.cdm_initialize_rpc_ = cdm_initialize_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_initialize_rpc)
}

// optional .media.remoting.pb.CdmSetServerCertificate cdm_setservercertificate_rpc = 501;
bool RpcMessage::has_cdm_setservercertificate_rpc() const {
  return rpc_oneof_case() == kCdmSetservercertificateRpc;
}
void RpcMessage::set_has_cdm_setservercertificate_rpc() {
  _oneof_case_[0] = kCdmSetservercertificateRpc;
}
void RpcMessage::clear_cdm_setservercertificate_rpc() {
  if (has_cdm_setservercertificate_rpc()) {
    delete rpc_oneof_.cdm_setservercertificate_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmSetServerCertificate& RpcMessage::cdm_setservercertificate_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_setservercertificate_rpc)
  return has_cdm_setservercertificate_rpc()
      ? *rpc_oneof_.cdm_setservercertificate_rpc_
      : ::media::remoting::pb::CdmSetServerCertificate::default_instance();
}
::media::remoting::pb::CdmSetServerCertificate* RpcMessage::mutable_cdm_setservercertificate_rpc() {
  if (!has_cdm_setservercertificate_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_setservercertificate_rpc();
    rpc_oneof_.cdm_setservercertificate_rpc_ = new ::media::remoting::pb::CdmSetServerCertificate;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_setservercertificate_rpc)
  return rpc_oneof_.cdm_setservercertificate_rpc_;
}
::media::remoting::pb::CdmSetServerCertificate* RpcMessage::release_cdm_setservercertificate_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_setservercertificate_rpc)
  if (has_cdm_setservercertificate_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmSetServerCertificate* temp = rpc_oneof_.cdm_setservercertificate_rpc_;
    rpc_oneof_.cdm_setservercertificate_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_setservercertificate_rpc(::media::remoting::pb::CdmSetServerCertificate* cdm_setservercertificate_rpc) {
  clear_rpc_oneof();
  if (cdm_setservercertificate_rpc) {
    set_has_cdm_setservercertificate_rpc();
    rpc_oneof_.cdm_setservercertificate_rpc_ = cdm_setservercertificate_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_setservercertificate_rpc)
}

// optional .media.remoting.pb.CdmCreateSessionAndGenerateRequest cdm_createsessionandgeneraterequest_rpc = 502;
bool RpcMessage::has_cdm_createsessionandgeneraterequest_rpc() const {
  return rpc_oneof_case() == kCdmCreatesessionandgeneraterequestRpc;
}
void RpcMessage::set_has_cdm_createsessionandgeneraterequest_rpc() {
  _oneof_case_[0] = kCdmCreatesessionandgeneraterequestRpc;
}
void RpcMessage::clear_cdm_createsessionandgeneraterequest_rpc() {
  if (has_cdm_createsessionandgeneraterequest_rpc()) {
    delete rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmCreateSessionAndGenerateRequest& RpcMessage::cdm_createsessionandgeneraterequest_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_createsessionandgeneraterequest_rpc)
  return has_cdm_createsessionandgeneraterequest_rpc()
      ? *rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_
      : ::media::remoting::pb::CdmCreateSessionAndGenerateRequest::default_instance();
}
::media::remoting::pb::CdmCreateSessionAndGenerateRequest* RpcMessage::mutable_cdm_createsessionandgeneraterequest_rpc() {
  if (!has_cdm_createsessionandgeneraterequest_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_createsessionandgeneraterequest_rpc();
    rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_ = new ::media::remoting::pb::CdmCreateSessionAndGenerateRequest;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_createsessionandgeneraterequest_rpc)
  return rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_;
}
::media::remoting::pb::CdmCreateSessionAndGenerateRequest* RpcMessage::release_cdm_createsessionandgeneraterequest_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_createsessionandgeneraterequest_rpc)
  if (has_cdm_createsessionandgeneraterequest_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmCreateSessionAndGenerateRequest* temp = rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_;
    rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_createsessionandgeneraterequest_rpc(::media::remoting::pb::CdmCreateSessionAndGenerateRequest* cdm_createsessionandgeneraterequest_rpc) {
  clear_rpc_oneof();
  if (cdm_createsessionandgeneraterequest_rpc) {
    set_has_cdm_createsessionandgeneraterequest_rpc();
    rpc_oneof_.cdm_createsessionandgeneraterequest_rpc_ = cdm_createsessionandgeneraterequest_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_createsessionandgeneraterequest_rpc)
}

// optional .media.remoting.pb.CdmLoadSession cdm_loadsession_rpc = 503;
bool RpcMessage::has_cdm_loadsession_rpc() const {
  return rpc_oneof_case() == kCdmLoadsessionRpc;
}
void RpcMessage::set_has_cdm_loadsession_rpc() {
  _oneof_case_[0] = kCdmLoadsessionRpc;
}
void RpcMessage::clear_cdm_loadsession_rpc() {
  if (has_cdm_loadsession_rpc()) {
    delete rpc_oneof_.cdm_loadsession_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmLoadSession& RpcMessage::cdm_loadsession_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_loadsession_rpc)
  return has_cdm_loadsession_rpc()
      ? *rpc_oneof_.cdm_loadsession_rpc_
      : ::media::remoting::pb::CdmLoadSession::default_instance();
}
::media::remoting::pb::CdmLoadSession* RpcMessage::mutable_cdm_loadsession_rpc() {
  if (!has_cdm_loadsession_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_loadsession_rpc();
    rpc_oneof_.cdm_loadsession_rpc_ = new ::media::remoting::pb::CdmLoadSession;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_loadsession_rpc)
  return rpc_oneof_.cdm_loadsession_rpc_;
}
::media::remoting::pb::CdmLoadSession* RpcMessage::release_cdm_loadsession_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_loadsession_rpc)
  if (has_cdm_loadsession_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmLoadSession* temp = rpc_oneof_.cdm_loadsession_rpc_;
    rpc_oneof_.cdm_loadsession_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_loadsession_rpc(::media::remoting::pb::CdmLoadSession* cdm_loadsession_rpc) {
  clear_rpc_oneof();
  if (cdm_loadsession_rpc) {
    set_has_cdm_loadsession_rpc();
    rpc_oneof_.cdm_loadsession_rpc_ = cdm_loadsession_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_loadsession_rpc)
}

// optional .media.remoting.pb.CdmUpdateSession cdm_updatesession_rpc = 504;
bool RpcMessage::has_cdm_updatesession_rpc() const {
  return rpc_oneof_case() == kCdmUpdatesessionRpc;
}
void RpcMessage::set_has_cdm_updatesession_rpc() {
  _oneof_case_[0] = kCdmUpdatesessionRpc;
}
void RpcMessage::clear_cdm_updatesession_rpc() {
  if (has_cdm_updatesession_rpc()) {
    delete rpc_oneof_.cdm_updatesession_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmUpdateSession& RpcMessage::cdm_updatesession_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_updatesession_rpc)
  return has_cdm_updatesession_rpc()
      ? *rpc_oneof_.cdm_updatesession_rpc_
      : ::media::remoting::pb::CdmUpdateSession::default_instance();
}
::media::remoting::pb::CdmUpdateSession* RpcMessage::mutable_cdm_updatesession_rpc() {
  if (!has_cdm_updatesession_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_updatesession_rpc();
    rpc_oneof_.cdm_updatesession_rpc_ = new ::media::remoting::pb::CdmUpdateSession;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_updatesession_rpc)
  return rpc_oneof_.cdm_updatesession_rpc_;
}
::media::remoting::pb::CdmUpdateSession* RpcMessage::release_cdm_updatesession_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_updatesession_rpc)
  if (has_cdm_updatesession_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmUpdateSession* temp = rpc_oneof_.cdm_updatesession_rpc_;
    rpc_oneof_.cdm_updatesession_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_updatesession_rpc(::media::remoting::pb::CdmUpdateSession* cdm_updatesession_rpc) {
  clear_rpc_oneof();
  if (cdm_updatesession_rpc) {
    set_has_cdm_updatesession_rpc();
    rpc_oneof_.cdm_updatesession_rpc_ = cdm_updatesession_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_updatesession_rpc)
}

// optional .media.remoting.pb.CdmCloseSession cdm_closesession_rpc = 505;
bool RpcMessage::has_cdm_closesession_rpc() const {
  return rpc_oneof_case() == kCdmClosesessionRpc;
}
void RpcMessage::set_has_cdm_closesession_rpc() {
  _oneof_case_[0] = kCdmClosesessionRpc;
}
void RpcMessage::clear_cdm_closesession_rpc() {
  if (has_cdm_closesession_rpc()) {
    delete rpc_oneof_.cdm_closesession_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmCloseSession& RpcMessage::cdm_closesession_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_closesession_rpc)
  return has_cdm_closesession_rpc()
      ? *rpc_oneof_.cdm_closesession_rpc_
      : ::media::remoting::pb::CdmCloseSession::default_instance();
}
::media::remoting::pb::CdmCloseSession* RpcMessage::mutable_cdm_closesession_rpc() {
  if (!has_cdm_closesession_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_closesession_rpc();
    rpc_oneof_.cdm_closesession_rpc_ = new ::media::remoting::pb::CdmCloseSession;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_closesession_rpc)
  return rpc_oneof_.cdm_closesession_rpc_;
}
::media::remoting::pb::CdmCloseSession* RpcMessage::release_cdm_closesession_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_closesession_rpc)
  if (has_cdm_closesession_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmCloseSession* temp = rpc_oneof_.cdm_closesession_rpc_;
    rpc_oneof_.cdm_closesession_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_closesession_rpc(::media::remoting::pb::CdmCloseSession* cdm_closesession_rpc) {
  clear_rpc_oneof();
  if (cdm_closesession_rpc) {
    set_has_cdm_closesession_rpc();
    rpc_oneof_.cdm_closesession_rpc_ = cdm_closesession_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_closesession_rpc)
}

// optional .media.remoting.pb.CdmRemoveSession cdm_removesession_rpc = 506;
bool RpcMessage::has_cdm_removesession_rpc() const {
  return rpc_oneof_case() == kCdmRemovesessionRpc;
}
void RpcMessage::set_has_cdm_removesession_rpc() {
  _oneof_case_[0] = kCdmRemovesessionRpc;
}
void RpcMessage::clear_cdm_removesession_rpc() {
  if (has_cdm_removesession_rpc()) {
    delete rpc_oneof_.cdm_removesession_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmRemoveSession& RpcMessage::cdm_removesession_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_removesession_rpc)
  return has_cdm_removesession_rpc()
      ? *rpc_oneof_.cdm_removesession_rpc_
      : ::media::remoting::pb::CdmRemoveSession::default_instance();
}
::media::remoting::pb::CdmRemoveSession* RpcMessage::mutable_cdm_removesession_rpc() {
  if (!has_cdm_removesession_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_removesession_rpc();
    rpc_oneof_.cdm_removesession_rpc_ = new ::media::remoting::pb::CdmRemoveSession;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_removesession_rpc)
  return rpc_oneof_.cdm_removesession_rpc_;
}
::media::remoting::pb::CdmRemoveSession* RpcMessage::release_cdm_removesession_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_removesession_rpc)
  if (has_cdm_removesession_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmRemoveSession* temp = rpc_oneof_.cdm_removesession_rpc_;
    rpc_oneof_.cdm_removesession_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_removesession_rpc(::media::remoting::pb::CdmRemoveSession* cdm_removesession_rpc) {
  clear_rpc_oneof();
  if (cdm_removesession_rpc) {
    set_has_cdm_removesession_rpc();
    rpc_oneof_.cdm_removesession_rpc_ = cdm_removesession_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_removesession_rpc)
}

// optional .media.remoting.pb.CdmPromise cdm_promise_rpc = 600;
bool RpcMessage::has_cdm_promise_rpc() const {
  return rpc_oneof_case() == kCdmPromiseRpc;
}
void RpcMessage::set_has_cdm_promise_rpc() {
  _oneof_case_[0] = kCdmPromiseRpc;
}
void RpcMessage::clear_cdm_promise_rpc() {
  if (has_cdm_promise_rpc()) {
    delete rpc_oneof_.cdm_promise_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmPromise& RpcMessage::cdm_promise_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdm_promise_rpc)
  return has_cdm_promise_rpc()
      ? *rpc_oneof_.cdm_promise_rpc_
      : ::media::remoting::pb::CdmPromise::default_instance();
}
::media::remoting::pb::CdmPromise* RpcMessage::mutable_cdm_promise_rpc() {
  if (!has_cdm_promise_rpc()) {
    clear_rpc_oneof();
    set_has_cdm_promise_rpc();
    rpc_oneof_.cdm_promise_rpc_ = new ::media::remoting::pb::CdmPromise;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdm_promise_rpc)
  return rpc_oneof_.cdm_promise_rpc_;
}
::media::remoting::pb::CdmPromise* RpcMessage::release_cdm_promise_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdm_promise_rpc)
  if (has_cdm_promise_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmPromise* temp = rpc_oneof_.cdm_promise_rpc_;
    rpc_oneof_.cdm_promise_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdm_promise_rpc(::media::remoting::pb::CdmPromise* cdm_promise_rpc) {
  clear_rpc_oneof();
  if (cdm_promise_rpc) {
    set_has_cdm_promise_rpc();
    rpc_oneof_.cdm_promise_rpc_ = cdm_promise_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdm_promise_rpc)
}

// optional .media.remoting.pb.CdmClientOnSessionMessage cdmclient_onsessionmessage_rpc = 601;
bool RpcMessage::has_cdmclient_onsessionmessage_rpc() const {
  return rpc_oneof_case() == kCdmclientOnsessionmessageRpc;
}
void RpcMessage::set_has_cdmclient_onsessionmessage_rpc() {
  _oneof_case_[0] = kCdmclientOnsessionmessageRpc;
}
void RpcMessage::clear_cdmclient_onsessionmessage_rpc() {
  if (has_cdmclient_onsessionmessage_rpc()) {
    delete rpc_oneof_.cdmclient_onsessionmessage_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmClientOnSessionMessage& RpcMessage::cdmclient_onsessionmessage_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdmclient_onsessionmessage_rpc)
  return has_cdmclient_onsessionmessage_rpc()
      ? *rpc_oneof_.cdmclient_onsessionmessage_rpc_
      : ::media::remoting::pb::CdmClientOnSessionMessage::default_instance();
}
::media::remoting::pb::CdmClientOnSessionMessage* RpcMessage::mutable_cdmclient_onsessionmessage_rpc() {
  if (!has_cdmclient_onsessionmessage_rpc()) {
    clear_rpc_oneof();
    set_has_cdmclient_onsessionmessage_rpc();
    rpc_oneof_.cdmclient_onsessionmessage_rpc_ = new ::media::remoting::pb::CdmClientOnSessionMessage;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdmclient_onsessionmessage_rpc)
  return rpc_oneof_.cdmclient_onsessionmessage_rpc_;
}
::media::remoting::pb::CdmClientOnSessionMessage* RpcMessage::release_cdmclient_onsessionmessage_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdmclient_onsessionmessage_rpc)
  if (has_cdmclient_onsessionmessage_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmClientOnSessionMessage* temp = rpc_oneof_.cdmclient_onsessionmessage_rpc_;
    rpc_oneof_.cdmclient_onsessionmessage_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdmclient_onsessionmessage_rpc(::media::remoting::pb::CdmClientOnSessionMessage* cdmclient_onsessionmessage_rpc) {
  clear_rpc_oneof();
  if (cdmclient_onsessionmessage_rpc) {
    set_has_cdmclient_onsessionmessage_rpc();
    rpc_oneof_.cdmclient_onsessionmessage_rpc_ = cdmclient_onsessionmessage_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdmclient_onsessionmessage_rpc)
}

// optional .media.remoting.pb.CdmClientOnSessionKeysChange cdmclient_onsessionkeychange_rpc = 602;
bool RpcMessage::has_cdmclient_onsessionkeychange_rpc() const {
  return rpc_oneof_case() == kCdmclientOnsessionkeychangeRpc;
}
void RpcMessage::set_has_cdmclient_onsessionkeychange_rpc() {
  _oneof_case_[0] = kCdmclientOnsessionkeychangeRpc;
}
void RpcMessage::clear_cdmclient_onsessionkeychange_rpc() {
  if (has_cdmclient_onsessionkeychange_rpc()) {
    delete rpc_oneof_.cdmclient_onsessionkeychange_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmClientOnSessionKeysChange& RpcMessage::cdmclient_onsessionkeychange_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdmclient_onsessionkeychange_rpc)
  return has_cdmclient_onsessionkeychange_rpc()
      ? *rpc_oneof_.cdmclient_onsessionkeychange_rpc_
      : ::media::remoting::pb::CdmClientOnSessionKeysChange::default_instance();
}
::media::remoting::pb::CdmClientOnSessionKeysChange* RpcMessage::mutable_cdmclient_onsessionkeychange_rpc() {
  if (!has_cdmclient_onsessionkeychange_rpc()) {
    clear_rpc_oneof();
    set_has_cdmclient_onsessionkeychange_rpc();
    rpc_oneof_.cdmclient_onsessionkeychange_rpc_ = new ::media::remoting::pb::CdmClientOnSessionKeysChange;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdmclient_onsessionkeychange_rpc)
  return rpc_oneof_.cdmclient_onsessionkeychange_rpc_;
}
::media::remoting::pb::CdmClientOnSessionKeysChange* RpcMessage::release_cdmclient_onsessionkeychange_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdmclient_onsessionkeychange_rpc)
  if (has_cdmclient_onsessionkeychange_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmClientOnSessionKeysChange* temp = rpc_oneof_.cdmclient_onsessionkeychange_rpc_;
    rpc_oneof_.cdmclient_onsessionkeychange_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdmclient_onsessionkeychange_rpc(::media::remoting::pb::CdmClientOnSessionKeysChange* cdmclient_onsessionkeychange_rpc) {
  clear_rpc_oneof();
  if (cdmclient_onsessionkeychange_rpc) {
    set_has_cdmclient_onsessionkeychange_rpc();
    rpc_oneof_.cdmclient_onsessionkeychange_rpc_ = cdmclient_onsessionkeychange_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdmclient_onsessionkeychange_rpc)
}

// optional .media.remoting.pb.CdmClientOnSessionExpirationUpdate cdmclient_onsessionexpirationupdate_rpc = 603;
bool RpcMessage::has_cdmclient_onsessionexpirationupdate_rpc() const {
  return rpc_oneof_case() == kCdmclientOnsessionexpirationupdateRpc;
}
void RpcMessage::set_has_cdmclient_onsessionexpirationupdate_rpc() {
  _oneof_case_[0] = kCdmclientOnsessionexpirationupdateRpc;
}
void RpcMessage::clear_cdmclient_onsessionexpirationupdate_rpc() {
  if (has_cdmclient_onsessionexpirationupdate_rpc()) {
    delete rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_;
    clear_has_rpc_oneof();
  }
}
 const ::media::remoting::pb::CdmClientOnSessionExpirationUpdate& RpcMessage::cdmclient_onsessionexpirationupdate_rpc() const {
  // @@protoc_insertion_point(field_get:media.remoting.pb.RpcMessage.cdmclient_onsessionexpirationupdate_rpc)
  return has_cdmclient_onsessionexpirationupdate_rpc()
      ? *rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_
      : ::media::remoting::pb::CdmClientOnSessionExpirationUpdate::default_instance();
}
::media::remoting::pb::CdmClientOnSessionExpirationUpdate* RpcMessage::mutable_cdmclient_onsessionexpirationupdate_rpc() {
  if (!has_cdmclient_onsessionexpirationupdate_rpc()) {
    clear_rpc_oneof();
    set_has_cdmclient_onsessionexpirationupdate_rpc();
    rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_ = new ::media::remoting::pb::CdmClientOnSessionExpirationUpdate;
  }
  // @@protoc_insertion_point(field_mutable:media.remoting.pb.RpcMessage.cdmclient_onsessionexpirationupdate_rpc)
  return rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_;
}
::media::remoting::pb::CdmClientOnSessionExpirationUpdate* RpcMessage::release_cdmclient_onsessionexpirationupdate_rpc() {
  // @@protoc_insertion_point(field_release:media.remoting.pb.RpcMessage.cdmclient_onsessionexpirationupdate_rpc)
  if (has_cdmclient_onsessionexpirationupdate_rpc()) {
    clear_has_rpc_oneof();
    ::media::remoting::pb::CdmClientOnSessionExpirationUpdate* temp = rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_;
    rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
void RpcMessage::set_allocated_cdmclient_onsessionexpirationupdate_rpc(::media::remoting::pb::CdmClientOnSessionExpirationUpdate* cdmclient_onsessionexpirationupdate_rpc) {
  clear_rpc_oneof();
  if (cdmclient_onsessionexpirationupdate_rpc) {
    set_has_cdmclient_onsessionexpirationupdate_rpc();
    rpc_oneof_.cdmclient_onsessionexpirationupdate_rpc_ = cdmclient_onsessionexpirationupdate_rpc;
  }
  // @@protoc_insertion_point(field_set_allocated:media.remoting.pb.RpcMessage.cdmclient_onsessionexpirationupdate_rpc)
}

bool RpcMessage::has_rpc_oneof() const {
  return rpc_oneof_case() != RPC_ONEOF_NOT_SET;
}
void RpcMessage::clear_has_rpc_oneof() {
  _oneof_case_[0] = RPC_ONEOF_NOT_SET;
}
RpcMessage::RpcOneofCase RpcMessage::rpc_oneof_case() const {
  return RpcMessage::RpcOneofCase(_oneof_case_[0]);
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

// @@protoc_insertion_point(namespace_scope)

}  // namespace pb
}  // namespace remoting
}  // namespace media

// @@protoc_insertion_point(global_scope)
