Error handling in media route provider

idationError.
NONE;
};
MediaRouteProvider_CreateRoute_Params.encodedSize = codec.kStructHeaderSize + 48;
MediaRouteProvider_CreateRoute_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_CreateRoute_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.mediaSource = decoder.decodeStruct(codec.String);
val.sinkId = decoder.decodeStruct(codec.String);
val.originalPresentationId = decoder.decodeStruct(codec.String);
val.origin = decoder.decodeStructPointer(origin$.Origin);
val.tabId = decoder.decodeStruct(codec.Int32);
packed = decoder.readUint8();
val.incognito = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.timeout = decoder.decodeStructPointer(time$.TimeDelta);
return val;
};
MediaRouteProvider_CreateRoute_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_CreateRoute_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.String, val.mediaSource);
encoder.encodeStruct(codec.String, val.sinkId);
encoder.encodeStruct(codec.String, val.originalPresentationId);
encoder.encodeStructPointer(origin$.Origin, val.origin);
encoder.encodeStruct(codec.Int32, val.tabId);
packed = 0;
packed |= (val.incognito & 1) << 0
encoder.writeUint8(packed);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStructPointer(time$.TimeDelta, val.timeout);
};
function MediaRouteProvider_CreateRoute_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
MediaRouteProvider_CreateRoute_ResponseParams.prototype.initDefaults_ =
function() {
this.route = null;
this.connection = null;
this.errorText = null;
this.resultCode = 0;
};
MediaRouteProvider_CreateRoute_ResponseParams.prototype.initFields_ =
function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
MediaRouteProvider_CreateRoute_ResponseParams.validate =
function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
return err;
var kVersionSizes = [
{version: 0, numBytes: 40}
];
err = messageValidator.validateStructVersion(offset, kVersionSizes);
return err;
// validate MediaRouteProvider_CreateRoute_ResponseParams.route
err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize +
0, MediaRoute, true);
return err;
// validate MediaRouteProvider_CreateRoute_ResponseParams.connection
8, RoutePresentationConnection, true);
return err;
// validate MediaRouteProvider_CreateRoute_ResponseParams.errorText
err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize +
16, true)
return err;
// validate MediaRouteProvider_CreateRoute_ResponseParams.resultCode
err = messageValidator.validateEnum(offset + codec.kStructHeaderSize + 24,
RouteRequestResultCode);
return err;
return validator.validationError.NONE;
};
MediaRouteProvider_CreateRoute_ResponseParams.encodedSize =
codec.kStructHeaderSize + 32;
MediaRouteProvider_CreateRoute_ResponseParams.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_CreateRoute_ResponseParams();
val.route = decoder.decodeStructPointer(MediaRoute);
val.connection = decoder.decodeStructPointer(RoutePresentationConnection);
val.errorText = decoder.decodeStruct(codec.NullableString);
val.resultCode = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_CreateRoute_ResponseParams.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_CreateRoute_ResponseParams.encodedSize);
encoder.encodeStructPointer(MediaRoute, val.route);
encoder.encodeStructPointer(RoutePresentationConnection, val.connection);
encoder.encodeStruct(codec.NullableString, val.errorText);
encoder.encodeStruct(codec.Int32, val.resultCode);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_JoinRoute_Params(values) {
}
MediaRouteProvider_JoinRoute_Params.prototype.initDefaults_ = function() {
this.mediaSource = null;
this.presentationId = null;
this.origin = null;
this.tabId = 0;
this.incognito = false;
this.timeout = null;
};
MediaRouteProvider_JoinRoute_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouteProvider_JoinRoute_Params.validate = function(messageValidator, offset)

{
var err;
return err;
];
return err;
// validate MediaRouteProvider_JoinRoute_Params.mediaSource
0, false)
return err;
// validate MediaRouteProvider_JoinRoute_Params.presentationId
8, false)
return err;
// validate MediaRouteProvider_JoinRoute_Params.origin
16, origin$.Origin, false);
return err;
// validate MediaRouteProvider_JoinRoute_Params.timeout
32, time$.TimeDelta, false);
return err;
};
MediaRouteProvider_JoinRoute_Params.encodedSize = codec.kStructHeaderSize + 40;
MediaRouteProvider_JoinRoute_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_JoinRoute_Params();
val.presentationId = decoder.decodeStruct(codec.String);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_JoinRoute_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_JoinRoute_Params.encodedSize);
encoder.encodeStruct(codec.String, val.presentationId);
packed = 0;
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_JoinRoute_ResponseParams(values) {
}
MediaRouteProvider_JoinRoute_ResponseParams.prototype.initDefaults_ = function()
{
this.route = null;
};
MediaRouteProvider_JoinRoute_ResponseParams.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_JoinRoute_ResponseParams.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_JoinRoute_ResponseParams.route
return err;
// validate MediaRouteProvider_JoinRoute_ResponseParams.connection
return err;
// validate MediaRouteProvider_JoinRoute_ResponseParams.errorText
16, true)
return err;
// validate MediaRouteProvider_JoinRoute_ResponseParams.resultCode
return err;
};
MediaRouteProvider_JoinRoute_ResponseParams.encodedSize = codec.kStructHeaderSize
+ 32;
MediaRouteProvider_JoinRoute_ResponseParams.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_JoinRoute_ResponseParams();
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_JoinRoute_ResponseParams.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_JoinRoute_ResponseParams.encodedSize);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_ConnectRouteByRouteId_Params(values) {
}
MediaRouteProvider_ConnectRouteByRouteId_Params.prototype.initDefaults_ =
function() {
this.routeId = null;
this.origin = null;
this.tabId = 0;
this.incognito = false;
this.timeout = null;
};
MediaRouteProvider_ConnectRouteByRouteId_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_ConnectRouteByRouteId_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_Params.mediaSource
0, false)
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_Params.routeId
8, false)
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_Params.presentationId
16, false)
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_Params.origin
24, origin$.Origin, false);
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_Params.timeout
40, time$.TimeDelta, false);
return err;
};
MediaRouteProvider_ConnectRouteByRouteId_Params.encodedSize =
MediaRouteProvider_ConnectRouteByRouteId_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_ConnectRouteByRouteId_Params();
val.routeId = decoder.decodeStruct(codec.String);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_ConnectRouteByRouteId_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_ConnectRouteByRouteId_Params.encodedSize);
encoder.encodeStruct(codec.String, val.routeId);
packed = 0;
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_ConnectRouteByRouteId_ResponseParams(values) {
}
MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.prototype.initDefaults_ =
function() {
this.route = null;
};
MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.route
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.connection
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.errorText
16, true)
return err;
// validate MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.resultCode
return err;
};
MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.encodedSize =
MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.decode =
function(decoder) {
var packed;
var val = new MediaRouteProvider_ConnectRouteByRouteId_ResponseParams();
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.encode =
function(encoder, val) {
var packed;
encoder.writeUint32(MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.encoded
Size);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_TerminateRoute_Params(values) {
}
MediaRouteProvider_TerminateRoute_Params.prototype.initDefaults_ = function() {
};
MediaRouteProvider_TerminateRoute_Params.prototype.initFields_ = function(fields)
{
}
};
MediaRouteProvider_TerminateRoute_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_TerminateRoute_Params.routeId
0, false)
return err;
};
MediaRouteProvider_TerminateRoute_Params.encodedSize = codec.kStructHeaderSize +
8;
MediaRouteProvider_TerminateRoute_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_TerminateRoute_Params();
return val;
};
MediaRouteProvider_TerminateRoute_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_TerminateRoute_Params.encodedSize);
};
function MediaRouteProvider_TerminateRoute_ResponseParams(values) {
}
MediaRouteProvider_TerminateRoute_ResponseParams.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_TerminateRoute_ResponseParams.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_TerminateRoute_ResponseParams.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_TerminateRoute_ResponseParams.errorText
0, true)
return err;
// validate MediaRouteProvider_TerminateRoute_ResponseParams.resultCode
return err;
};
MediaRouteProvider_TerminateRoute_ResponseParams.encodedSize =
MediaRouteProvider_TerminateRoute_ResponseParams.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_TerminateRoute_ResponseParams();
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_TerminateRoute_ResponseParams.encode = function(encoder, val)

{
var packed;
encoder.writeUint32(MediaRouteProvider_TerminateRoute_ResponseParams.encodedSize);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_SendRouteMessage_Params(values) {
}
MediaRouteProvider_SendRouteMessage_Params.prototype.initDefaults_ = function() {
this.mediaRouteId = null;
this.message = null;
};
MediaRouteProvider_SendRouteMessage_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_SendRouteMessage_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_SendRouteMessage_Params.mediaRouteId
0, false)
return err;
// validate MediaRouteProvider_SendRouteMessage_Params.message
8, false)
return err;
};
MediaRouteProvider_SendRouteMessage_Params.encodedSize = codec.kStructHeaderSize
+ 16;
MediaRouteProvider_SendRouteMessage_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_SendRouteMessage_Params();
val.mediaRouteId = decoder.decodeStruct(codec.String);
val.message = decoder.decodeStruct(codec.String);
return val;
};
MediaRouteProvider_SendRouteMessage_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_SendRouteMessage_Params.encodedSize);
encoder.encodeStruct(codec.String, val.mediaRouteId);
encoder.encodeStruct(codec.String, val.message);
};
function MediaRouteProvider_SendRouteBinaryMessage_Params(values) {
}
MediaRouteProvider_SendRouteBinaryMessage_Params.prototype.initDefaults_ =
function() {
this.mediaRouteId = null;
this.data = null;
};
MediaRouteProvider_SendRouteBinaryMessage_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_SendRouteBinaryMessage_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_SendRouteBinaryMessage_Params.mediaRouteId
0, false)
return err;
// validate MediaRouteProvider_SendRouteBinaryMessage_Params.data
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize +
8, 1, codec.Uint8, false, [0], 0);
return err;
};
MediaRouteProvider_SendRouteBinaryMessage_Params.encodedSize =
MediaRouteProvider_SendRouteBinaryMessage_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_SendRouteBinaryMessage_Params();
val.mediaRouteId = decoder.decodeStruct(codec.String);
val.data = decoder.decodeArrayPointer(codec.Uint8);
return val;
};
MediaRouteProvider_SendRouteBinaryMessage_Params.encode = function(encoder, val)

{
var packed;
encoder.writeUint32(MediaRouteProvider_SendRouteBinaryMessage_Params.encodedSize);
encoder.encodeStruct(codec.String, val.mediaRouteId);
encoder.encodeArrayPointer(codec.Uint8, val.data);
};
function MediaRouteProvider_StartObservingMediaSinks_Params(values) {
}
MediaRouteProvider_StartObservingMediaSinks_Params.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_StartObservingMediaSinks_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_StartObservingMediaSinks_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_StartObservingMediaSinks_Params.mediaSource
0, false)
return err;
};
MediaRouteProvider_StartObservingMediaSinks_Params.encodedSize =
MediaRouteProvider_StartObservingMediaSinks_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_StartObservingMediaSinks_Params();
return val;
};
MediaRouteProvider_StartObservingMediaSinks_Params.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouteProvider_StartObservingMediaSinks_Params.encodedSize)
;
};
function MediaRouteProvider_StopObservingMediaSinks_Params(values) {
}
MediaRouteProvider_StopObservingMediaSinks_Params.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_StopObservingMediaSinks_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_StopObservingMediaSinks_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_StopObservingMediaSinks_Params.mediaSource
0, false)
return err;
};
MediaRouteProvider_StopObservingMediaSinks_Params.encodedSize =
MediaRouteProvider_StopObservingMediaSinks_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_StopObservingMediaSinks_Params();
return val;
};
MediaRouteProvider_StopObservingMediaSinks_Params.encode = function(encoder, val)

{
var packed;
encoder.writeUint32(MediaRouteProvider_StopObservingMediaSinks_Params.encodedSize);
};
function MediaRouteProvider_StartObservingMediaRoutes_Params(values) {
}
MediaRouteProvider_StartObservingMediaRoutes_Params.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_StartObservingMediaRoutes_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_StartObservingMediaRoutes_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_StartObservingMediaRoutes_Params.mediaSource
0, false)
return err;
};
MediaRouteProvider_StartObservingMediaRoutes_Params.encodedSize =
MediaRouteProvider_StartObservingMediaRoutes_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_StartObservingMediaRoutes_Params();
return val;
};
MediaRouteProvider_StartObservingMediaRoutes_Params.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouteProvider_StartObservingMediaRoutes_Params.encodedSize
);
};
function MediaRouteProvider_StopObservingMediaRoutes_Params(values) {
}
MediaRouteProvider_StopObservingMediaRoutes_Params.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_StopObservingMediaRoutes_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_StopObservingMediaRoutes_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_StopObservingMediaRoutes_Params.mediaSource
0, false)
return err;
};
MediaRouteProvider_StopObservingMediaRoutes_Params.encodedSize =
MediaRouteProvider_StopObservingMediaRoutes_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_StopObservingMediaRoutes_Params();
return val;
};
MediaRouteProvider_StopObservingMediaRoutes_Params.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouteProvider_StopObservingMediaRoutes_Params.encodedSize)
;
};
function MediaRouteProvider_StartListeningForRouteMessages_Params(values) {
}
MediaRouteProvider_StartListeningForRouteMessages_Params.prototype.initDefaults_
= function() {
};
MediaRouteProvider_StartListeningForRouteMessages_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_StartListeningForRouteMessages_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_StartListeningForRouteMessages_Params.routeId
0, false)
return err;
};
MediaRouteProvider_StartListeningForRouteMessages_Params.encodedSize =
MediaRouteProvider_StartListeningForRouteMessages_Params.decode =
function(decoder) {
var packed;
var val = new MediaRouteProvider_StartListeningForRouteMessages_Params();
return val;
};
MediaRouteProvider_StartListeningForRouteMessages_Params.encode =
var packed;
encoder.writeUint32(MediaRouteProvider_StartListeningForRouteMessages_Params.encode
dSize);
};
function MediaRouteProvider_StopListeningForRouteMessages_Params(values) {
}
MediaRouteProvider_StopListeningForRouteMessages_Params.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_StopListeningForRouteMessages_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_StopListeningForRouteMessages_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_StopListeningForRouteMessages_Params.routeId
0, false)
return err;
};
MediaRouteProvider_StopListeningForRouteMessages_Params.encodedSize =
MediaRouteProvider_StopListeningForRouteMessages_Params.decode =
function(decoder) {
var packed;
var val = new MediaRouteProvider_StopListeningForRouteMessages_Params();
return val;
};
MediaRouteProvider_StopListeningForRouteMessages_Params.encode =
var packed;
encoder.writeUint32(MediaRouteProvider_StopListeningForRouteMessages_Params.encoded
Size);
};
function MediaRouteProvider_DetachRoute_Params(values) {
}
MediaRouteProvider_DetachRoute_Params.prototype.initDefaults_ = function() {
};
MediaRouteProvider_DetachRoute_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouteProvider_DetachRoute_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_DetachRoute_Params.routeId
0, false)
return err;
};
MediaRouteProvider_DetachRoute_Params.encodedSize = codec.kStructHeaderSize + 8;
MediaRouteProvider_DetachRoute_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_DetachRoute_Params();
return val;
};
MediaRouteProvider_DetachRoute_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_DetachRoute_Params.encodedSize);
};
function MediaRouteProvider_EnableMdnsDiscovery_Params(values) {
}
MediaRouteProvider_EnableMdnsDiscovery_Params.prototype.initDefaults_ =
function() {
};
MediaRouteProvider_EnableMdnsDiscovery_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_EnableMdnsDiscovery_Params.validate =
var err;
return err;
];
return err;
};
MediaRouteProvider_EnableMdnsDiscovery_Params.encodedSize =
MediaRouteProvider_EnableMdnsDiscovery_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_EnableMdnsDiscovery_Params();
return val;
};
MediaRouteProvider_EnableMdnsDiscovery_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_EnableMdnsDiscovery_Params.encodedSize);
};
function MediaRouteProvider_UpdateMediaSinks_Params(values) {
}
MediaRouteProvider_UpdateMediaSinks_Params.prototype.initDefaults_ = function() {
};
MediaRouteProvider_UpdateMediaSinks_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_UpdateMediaSinks_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_UpdateMediaSinks_Params.mediaSource
0, false)
return err;
};
MediaRouteProvider_UpdateMediaSinks_Params.encodedSize = codec.kStructHeaderSize
+ 8;
MediaRouteProvider_UpdateMediaSinks_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_UpdateMediaSinks_Params();
return val;
};
MediaRouteProvider_UpdateMediaSinks_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_UpdateMediaSinks_Params.encodedSize);
};
function MediaRouteProvider_SearchSinks_Params(values) {
}
MediaRouteProvider_SearchSinks_Params.prototype.initDefaults_ = function() {
this.sinkId = null;
this.searchCriteria = null;
};
MediaRouteProvider_SearchSinks_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouteProvider_SearchSinks_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_SearchSinks_Params.sinkId
0, false)
return err;
// validate MediaRouteProvider_SearchSinks_Params.mediaSource
8, false)
return err;
// validate MediaRouteProvider_SearchSinks_Params.searchCriteria
16, SinkSearchCriteria, false);
return err;
};
MediaRouteProvider_SearchSinks_Params.encodedSize = codec.kStructHeaderSize + 24;
MediaRouteProvider_SearchSinks_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_SearchSinks_Params();
val.searchCriteria = decoder.decodeStructPointer(SinkSearchCriteria);
return val;
};
MediaRouteProvider_SearchSinks_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_SearchSinks_Params.encodedSize);
encoder.encodeStructPointer(SinkSearchCriteria, val.searchCriteria);
};
function MediaRouteProvider_SearchSinks_ResponseParams(values) {
}
MediaRouteProvider_SearchSinks_ResponseParams.prototype.initDefaults_ =
function() {
this.sinkId = null;
};
MediaRouteProvider_SearchSinks_ResponseParams.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_SearchSinks_ResponseParams.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_SearchSinks_ResponseParams.sinkId
0, false)
return err;
};
MediaRouteProvider_SearchSinks_ResponseParams.encodedSize =
MediaRouteProvider_SearchSinks_ResponseParams.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_SearchSinks_ResponseParams();
return val;
};
MediaRouteProvider_SearchSinks_ResponseParams.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_SearchSinks_ResponseParams.encodedSize);
};
function MediaRouteProvider_ProvideSinks_Params(values) {
}
MediaRouteProvider_ProvideSinks_Params.prototype.initDefaults_ = function() {
this.providerName = null;
this.sinks = null;
};
MediaRouteProvider_ProvideSinks_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouteProvider_ProvideSinks_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouteProvider_ProvideSinks_Params.providerName
0, false)
return err;
// validate MediaRouteProvider_ProvideSinks_Params.sinks
8, 8, new codec.PointerTo(MediaSink), false, [0], 0);
return err;
};
MediaRouteProvider_ProvideSinks_Params.encodedSize = codec.kStructHeaderSize +
16;
MediaRouteProvider_ProvideSinks_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_ProvideSinks_Params();
val.providerName = decoder.decodeStruct(codec.String);
val.sinks = decoder.decodeArrayPointer(new codec.PointerTo(MediaSink));
return val;
};
MediaRouteProvider_ProvideSinks_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouteProvider_ProvideSinks_Params.encodedSize);
encoder.encodeStruct(codec.String, val.providerName);
encoder.encodeArrayPointer(new codec.PointerTo(MediaSink), val.sinks);
};
function MediaRouteProvider_CreateMediaRouteController_Params(values) {
}
MediaRouteProvider_CreateMediaRouteController_Params.prototype.initDefaults_ =
function() {
this.mediaController = new bindings.InterfaceRequest();
this.observer = new media_status$.MediaStatusObserverPtr();
};
MediaRouteProvider_CreateMediaRouteController_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouteProvider_CreateMediaRouteController_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouteProvider_CreateMediaRouteController_Params.routeId
0, false)
return err;
// validate
MediaRouteProvider_CreateMediaRouteController_Params.mediaController
err = messageValidator.validateInterfaceRequest(offset +
codec.kStructHeaderSize + 8, false)
return err;
// validate MediaRouteProvider_CreateMediaRouteController_Params.observer
err = messageValidator.validateInterface(offset + codec.kStructHeaderSize + 12,
false);
return err;
};
MediaRouteProvider_CreateMediaRouteController_Params.encodedSize =
MediaRouteProvider_CreateMediaRouteController_Params.decode = function(decoder) {
var packed;
var val = new MediaRouteProvider_CreateMediaRouteController_Params();
val.mediaController = decoder.decodeStruct(codec.InterfaceRequest);
val.observer = decoder.decodeStruct(new
codec.Interface(media_status$.MediaStatusObserverPtr));
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_CreateMediaRouteController_Params.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouteProvider_CreateMediaRouteController_Params.encodedSiz
e);
encoder.encodeStruct(codec.InterfaceRequest, val.mediaController);
encoder.encodeStruct(new codec.Interface(media_status$.MediaStatusObserverPtr),
val.observer);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouteProvider_CreateMediaRouteController_ResponseParams(values) {
}
MediaRouteProvider_CreateMediaRouteController_ResponseParams.prototype.initDefaults
_ = function() {
this.success = false;
};
MediaRouteProvider_CreateMediaRouteController_ResponseParams.prototype.initFields_
= function(fields) {
}
};
MediaRouteProvider_CreateMediaRouteController_ResponseParams.validate =
var err;
return err;
];
return err;
};
MediaRouteProvider_CreateMediaRouteController_ResponseParams.encodedSize =
MediaRouteProvider_CreateMediaRouteController_ResponseParams.decode =
function(decoder) {
var packed;
var val = new MediaRouteProvider_CreateMediaRouteController_ResponseParams();
val.success = (packed >> 0) & 1 ? true : false;
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouteProvider_CreateMediaRouteController_ResponseParams.encode =
var packed;
encoder.writeUint32(MediaRouteProvider_CreateMediaRouteController_ResponseParams.en
codedSize);
packed = 0;
packed |= (val.success & 1) << 0
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouter_RegisterMediaRouteProvider_Params(values) {
}
MediaRouter_RegisterMediaRouteProvider_Params.prototype.initDefaults_ =
function() {
this.providerId = 0;
this.mediaRouterProvider = new MediaRouteProviderPtr();
};
MediaRouter_RegisterMediaRouteProvider_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_RegisterMediaRouteProvider_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouter_RegisterMediaRouteProvider_Params.providerId
MediaRouteProvider.Id);
return err;
// validate MediaRouter_RegisterMediaRouteProvider_Params.mediaRouterProvider
false);
return err;
};
MediaRouter_RegisterMediaRouteProvider_Params.encodedSize =
MediaRouter_RegisterMediaRouteProvider_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_RegisterMediaRouteProvider_Params();
val.providerId = decoder.decodeStruct(codec.Int32);
val.mediaRouterProvider = decoder.decodeStruct(new
codec.Interface(MediaRouteProviderPtr));
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouter_RegisterMediaRouteProvider_Params.encode = function(encoder, val) {
var packed;
encoder.writeUint32(MediaRouter_RegisterMediaRouteProvider_Params.encodedSize);
encoder.encodeStruct(codec.Int32, val.providerId);
encoder.encodeStruct(new codec.Interface(MediaRouteProviderPtr),
val.mediaRouterProvider);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouter_RegisterMediaRouteProvider_ResponseParams(values) {
}
MediaRouter_RegisterMediaRouteProvider_ResponseParams.prototype.initDefaults_ =
function() {
this.instanceId = null;
this.config = null;
};
MediaRouter_RegisterMediaRouteProvider_ResponseParams.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_RegisterMediaRouteProvider_ResponseParams.validate =
var err;
return err;
];
return err;
// validate MediaRouter_RegisterMediaRouteProvider_ResponseParams.instanceId
0, false)
return err;
// validate MediaRouter_RegisterMediaRouteProvider_ResponseParams.config
8, MediaRouteProviderConfig, false);
return err;
};
MediaRouter_RegisterMediaRouteProvider_ResponseParams.encodedSize =
MediaRouter_RegisterMediaRouteProvider_ResponseParams.decode = function(decoder)
{
var packed;
var val = new MediaRouter_RegisterMediaRouteProvider_ResponseParams();
val.instanceId = decoder.decodeStruct(codec.String);
val.config = decoder.decodeStructPointer(MediaRouteProviderConfig);
return val;
};
MediaRouter_RegisterMediaRouteProvider_ResponseParams.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouter_RegisterMediaRouteProvider_ResponseParams.encodedSi
ze);
encoder.encodeStruct(codec.String, val.instanceId);
encoder.encodeStructPointer(MediaRouteProviderConfig, val.config);
};
function MediaRouter_OnSinksReceived_Params(values) {
}
MediaRouter_OnSinksReceived_Params.prototype.initDefaults_ = function() {
this.sinks = null;
this.origins = null;
};
MediaRouter_OnSinksReceived_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouter_OnSinksReceived_Params.validate = function(messageValidator, offset)

{
var err;
return err;
];
return err;
// validate MediaRouter_OnSinksReceived_Params.providerId
return err;
// validate MediaRouter_OnSinksReceived_Params.mediaSource
8, false)
return err;
// validate MediaRouter_OnSinksReceived_Params.sinks
16, 8, new codec.PointerTo(MediaSink), false, [0], 0);
return err;
// validate MediaRouter_OnSinksReceived_Params.origins
24, 8, new codec.PointerTo(origin$.Origin), false, [0], 0);
return err;
};
MediaRouter_OnSinksReceived_Params.encodedSize = codec.kStructHeaderSize + 32;
MediaRouter_OnSinksReceived_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnSinksReceived_Params();
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.sinks = decoder.decodeArrayPointer(new codec.PointerTo(MediaSink));
val.origins = decoder.decodeArrayPointer(new codec.PointerTo(origin$.Origin));
return val;
};
MediaRouter_OnSinksReceived_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_OnSinksReceived_Params.encodedSize);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeArrayPointer(new codec.PointerTo(MediaSink), val.sinks);
encoder.encodeArrayPointer(new codec.PointerTo(origin$.Origin), val.origins);
};
function MediaRouter_OnIssue_Params(values) {
}
MediaRouter_OnIssue_Params.prototype.initDefaults_ = function() {
this.issue = null;
};
MediaRouter_OnIssue_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouter_OnIssue_Params.validate = function(messageValidator, offset) {

var err;
return err;
];
return err;
// validate MediaRouter_OnIssue_Params.issue
0, Issue, false);
return err;
};
MediaRouter_OnIssue_Params.encodedSize = codec.kStructHeaderSize + 8;
MediaRouter_OnIssue_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnIssue_Params();
val.issue = decoder.decodeStructPointer(Issue);
return val;
};
MediaRouter_OnIssue_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_OnIssue_Params.encodedSize);
encoder.encodeStructPointer(Issue, val.issue);
};
function MediaRouter_OnRoutesUpdated_Params(values) {
}
MediaRouter_OnRoutesUpdated_Params.prototype.initDefaults_ = function() {
this.routes = null;
this.joinableRouteIds = null;
};
MediaRouter_OnRoutesUpdated_Params.prototype.initFields_ = function(fields) {
}
};
MediaRouter_OnRoutesUpdated_Params.validate = function(messageValidator, offset)

{
var err;
return err;
];
return err;
// validate MediaRouter_OnRoutesUpdated_Params.providerId
return err;
// validate MediaRouter_OnRoutesUpdated_Params.routes
8, 8, new codec.PointerTo(MediaRoute), false, [0], 0);
return err;
// validate MediaRouter_OnRoutesUpdated_Params.mediaSource
16, false)
return err;
// validate MediaRouter_OnRoutesUpdated_Params.joinableRouteIds
24, 8, codec.String, false, [0, 0], 0);
return err;
};
MediaRouter_OnRoutesUpdated_Params.encodedSize = codec.kStructHeaderSize + 32;
MediaRouter_OnRoutesUpdated_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnRoutesUpdated_Params();
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.routes = decoder.decodeArrayPointer(new codec.PointerTo(MediaRoute));
val.joinableRouteIds = decoder.decodeArrayPointer(codec.String);
return val;
};
MediaRouter_OnRoutesUpdated_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_OnRoutesUpdated_Params.encodedSize);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeArrayPointer(new codec.PointerTo(MediaRoute), val.routes);
encoder.encodeArrayPointer(codec.String, val.joinableRouteIds);
};
function MediaRouter_OnSinkAvailabilityUpdated_Params(values) {
}
MediaRouter_OnSinkAvailabilityUpdated_Params.prototype.initDefaults_ = function()
{
this.availability = 0;
};
MediaRouter_OnSinkAvailabilityUpdated_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_OnSinkAvailabilityUpdated_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouter_OnSinkAvailabilityUpdated_Params.providerId
return err;
// validate MediaRouter_OnSinkAvailabilityUpdated_Params.availability
MediaRouter.SinkAvailability);
return err;
};
MediaRouter_OnSinkAvailabilityUpdated_Params.encodedSize =
MediaRouter_OnSinkAvailabilityUpdated_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnSinkAvailabilityUpdated_Params();
val.availability = decoder.decodeStruct(codec.Int32);
return val;
};
MediaRouter_OnSinkAvailabilityUpdated_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_OnSinkAvailabilityUpdated_Params.encodedSize);
encoder.encodeStruct(codec.Int32, val.availability);
};
function MediaRouter_OnPresentationConnectionStateChanged_Params(values) {
}
MediaRouter_OnPresentationConnectionStateChanged_Params.prototype.initDefaults_ =
function() {
this.state = 0;
};
MediaRouter_OnPresentationConnectionStateChanged_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_OnPresentationConnectionStateChanged_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouter_OnPresentationConnectionStateChanged_Params.routeId
0, false)
return err;
// validate MediaRouter_OnPresentationConnectionStateChanged_Params.state
MediaRouter.PresentationConnectionState);
return err;
};
MediaRouter_OnPresentationConnectionStateChanged_Params.encodedSize =
MediaRouter_OnPresentationConnectionStateChanged_Params.decode =
function(decoder) {
var packed;
var val = new MediaRouter_OnPresentationConnectionStateChanged_Params();
val.state = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouter_OnPresentationConnectionStateChanged_Params.encode =
var packed;
encoder.writeUint32(MediaRouter_OnPresentationConnectionStateChanged_Params.encoded
Size);
encoder.encodeStruct(codec.Int32, val.state);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaRouter_OnPresentationConnectionClosed_Params(values) {
}
MediaRouter_OnPresentationConnectionClosed_Params.prototype.initDefaults_ =
function() {
this.reason = 0;
this.message = null;
};
MediaRouter_OnPresentationConnectionClosed_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_OnPresentationConnectionClosed_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouter_OnPresentationConnectionClosed_Params.routeId
0, false)
return err;
// validate MediaRouter_OnPresentationConnectionClosed_Params.reason
MediaRouter.PresentationConnectionCloseReason);
return err;
// validate MediaRouter_OnPresentationConnectionClosed_Params.message
16, false)
return err;
};
MediaRouter_OnPresentationConnectionClosed_Params.encodedSize =
MediaRouter_OnPresentationConnectionClosed_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnPresentationConnectionClosed_Params();
val.reason = decoder.decodeStruct(codec.Int32);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
val.message = decoder.decodeStruct(codec.String);
return val;
};
MediaRouter_OnPresentationConnectionClosed_Params.encode = function(encoder, val)

{
var packed;
encoder.writeUint32(MediaRouter_OnPresentationConnectionClosed_Params.encodedSize);
encoder.encodeStruct(codec.Int32, val.reason);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.encodeStruct(codec.String, val.message);
};
function MediaRouter_OnRouteMessagesReceived_Params(values) {
}
MediaRouter_OnRouteMessagesReceived_Params.prototype.initDefaults_ = function() {
this.messages = null;
};
MediaRouter_OnRouteMessagesReceived_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_OnRouteMessagesReceived_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouter_OnRouteMessagesReceived_Params.routeId
0, false)
return err;
// validate MediaRouter_OnRouteMessagesReceived_Params.messages
8, 8, new codec.PointerTo(RouteMessage), false, [0], 0);
return err;
};
MediaRouter_OnRouteMessagesReceived_Params.encodedSize = codec.kStructHeaderSize
+ 16;
MediaRouter_OnRouteMessagesReceived_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnRouteMessagesReceived_Params();
val.messages = decoder.decodeArrayPointer(new codec.PointerTo(RouteMessage));
return val;
};
MediaRouter_OnRouteMessagesReceived_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_OnRouteMessagesReceived_Params.encodedSize);
encoder.encodeArrayPointer(new codec.PointerTo(RouteMessage), val.messages);
};
function MediaRouter_OnMediaRemoterCreated_Params(values) {
}
MediaRouter_OnMediaRemoterCreated_Params.prototype.initDefaults_ = function() {
this.tabId = 0;
this.remoter = new mirror_service_remoting$.MirrorServiceRemoterPtr();
this.remotingSource = new bindings.InterfaceRequest();
};
MediaRouter_OnMediaRemoterCreated_Params.prototype.initFields_ = function(fields)
{
}
};
MediaRouter_OnMediaRemoterCreated_Params.validate = function(messageValidator,
offset) {
var err;
return err;
];
return err;
// validate MediaRouter_OnMediaRemoterCreated_Params.remoter
false);
return err;
// validate MediaRouter_OnMediaRemoterCreated_Params.remotingSource
return err;
};
MediaRouter_OnMediaRemoterCreated_Params.encodedSize = codec.kStructHeaderSize +
16;
MediaRouter_OnMediaRemoterCreated_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_OnMediaRemoterCreated_Params();
val.remoter = decoder.decodeStruct(new
codec.Interface(mirror_service_remoting$.MirrorServiceRemoterPtr));
val.remotingSource = decoder.decodeStruct(codec.InterfaceRequest);
return val;
};
MediaRouter_OnMediaRemoterCreated_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_OnMediaRemoterCreated_Params.encodedSize);
encoder.encodeStruct(new
codec.Interface(mirror_service_remoting$.MirrorServiceRemoterPtr), val.remoter);
encoder.encodeStruct(codec.InterfaceRequest, val.remotingSource);
};
function MediaRouter_GetMediaSinkServiceStatus_Params(values) {
}
MediaRouter_GetMediaSinkServiceStatus_Params.prototype.initDefaults_ = function()
{
};
MediaRouter_GetMediaSinkServiceStatus_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_GetMediaSinkServiceStatus_Params.validate =
var err;
return err;
];
return err;
};
MediaRouter_GetMediaSinkServiceStatus_Params.encodedSize =
MediaRouter_GetMediaSinkServiceStatus_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_GetMediaSinkServiceStatus_Params();
return val;
};
MediaRouter_GetMediaSinkServiceStatus_Params.encode = function(encoder, val) {

var packed;
encoder.writeUint32(MediaRouter_GetMediaSinkServiceStatus_Params.encodedSize);
};
function MediaRouter_GetMediaSinkServiceStatus_ResponseParams(values) {
}
MediaRouter_GetMediaSinkServiceStatus_ResponseParams.prototype.initDefaults_ =
function() {
this.status = null;
};
MediaRouter_GetMediaSinkServiceStatus_ResponseParams.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_GetMediaSinkServiceStatus_ResponseParams.validate =
var err;
return err;
];
return err;
// validate MediaRouter_GetMediaSinkServiceStatus_ResponseParams.status
0, false)
return err;
};
MediaRouter_GetMediaSinkServiceStatus_ResponseParams.encodedSize =
MediaRouter_GetMediaSinkServiceStatus_ResponseParams.decode = function(decoder) {
var packed;
var val = new MediaRouter_GetMediaSinkServiceStatus_ResponseParams();
val.status = decoder.decodeStruct(codec.String);
return val;
};
MediaRouter_GetMediaSinkServiceStatus_ResponseParams.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouter_GetMediaSinkServiceStatus_ResponseParams.encodedSiz
e);
encoder.encodeStruct(codec.String, val.status);
};
function MediaRouter_GetMirroringServiceHostForTab_Params(values) {
}
MediaRouter_GetMirroringServiceHostForTab_Params.prototype.initDefaults_ =
function() {
this.targetTabId = 0;
this.request = new bindings.InterfaceRequest();
};
MediaRouter_GetMirroringServiceHostForTab_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_GetMirroringServiceHostForTab_Params.validate =
var err;
return err;
];
return err;
// validate MediaRouter_GetMirroringServiceHostForTab_Params.request
return err;
};
MediaRouter_GetMirroringServiceHostForTab_Params.encodedSize =
MediaRouter_GetMirroringServiceHostForTab_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_GetMirroringServiceHostForTab_Params();
val.targetTabId = decoder.decodeStruct(codec.Int32);
val.request = decoder.decodeStruct(codec.InterfaceRequest);
return val;
};
MediaRouter_GetMirroringServiceHostForTab_Params.encode = function(encoder, val)

{
var packed;
encoder.writeUint32(MediaRouter_GetMirroringServiceHostForTab_Params.encodedSize);
encoder.encodeStruct(codec.Int32, val.targetTabId);
encoder.encodeStruct(codec.InterfaceRequest, val.request);
};
function MediaRouter_GetMirroringServiceHostForDesktop_Params(values) {
}
MediaRouter_GetMirroringServiceHostForDesktop_Params.prototype.initDefaults_ =
function() {
this.initiatorTabId = 0;
this.desktopStreamId = null;
};
MediaRouter_GetMirroringServiceHostForDesktop_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_GetMirroringServiceHostForDesktop_Params.validate =
var err;
return err;
];
return err;
// validate
MediaRouter_GetMirroringServiceHostForDesktop_Params.desktopStreamId
8, false)
return err;
// validate MediaRouter_GetMirroringServiceHostForDesktop_Params.request
return err;
};
MediaRouter_GetMirroringServiceHostForDesktop_Params.encodedSize =
MediaRouter_GetMirroringServiceHostForDesktop_Params.decode = function(decoder) {
var packed;
var val = new MediaRouter_GetMirroringServiceHostForDesktop_Params();
val.initiatorTabId = decoder.decodeStruct(codec.Int32);
val.desktopStreamId = decoder.decodeStruct(codec.String);
return val;
};
MediaRouter_GetMirroringServiceHostForDesktop_Params.encode = function(encoder,
val) {
var packed;
encoder.writeUint32(MediaRouter_GetMirroringServiceHostForDesktop_Params.encodedSiz
e);
encoder.encodeStruct(codec.Int32, val.initiatorTabId);
encoder.encodeStruct(codec.String, val.desktopStreamId);
};
function MediaRouter_GetMirroringServiceHostForOffscreenTab_Params(values) {
}
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.prototype.initDefaults_
= function() {
this.presentationUrl = null;
};
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.prototype.initFields_ =
function(fields) {
}
};
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.validate =
var err;
return err;
];
return err;
// validate
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.presentationUrl
0, url$.Url, false);
return err;
// validate
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.presentationId
8, false)
return err;
// validate MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.request
return err;
};
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.encodedSize =
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.decode =
function(decoder) {
var packed;
var val = new MediaRouter_GetMirroringServiceHostForOffscreenTab_Params();
val.presentationUrl = decoder.decodeStructPointer(url$.Url);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
decoder.skip(1);
return val;
};
MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.encode =
var packed;
encoder.writeUint32(MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.encod
edSize);
encoder.encodeStructPointer(url$.Url, val.presentationUrl);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
encoder.skip(1);
};
function MediaSinkExtraData(value) {
this.initDefault_();
this.initValue_(value);
}
MediaSinkExtraData.Tags = {
dialMediaSink: 0,
castMediaSink: 1,
};
MediaSinkExtraData.prototype.initDefault_ = function() {
this.$data = null;
this.$tag = undefined;
}
MediaSinkExtraData.prototype.initValue_ = function(value) {
if (value == undefined) {
return;
}
var keys = Object.keys(value);

if (keys.length == 0) {
return;
}
if (keys.length > 1) {
throw new TypeError("You may set only one member on a union.");
}
var fields = [
"dialMediaSink",
"castMediaSink",
];
if (fields.indexOf(keys[0]) < 0) {
throw new ReferenceError(keys[0] + " is not a MediaSinkExtraData member.");
this[keys[0]] = value[keys[0]];
}
Object.defineProperty(MediaSinkExtraData.prototype, "dialMediaSink", {
get: function() {
if (this.$tag != MediaSinkExtraData.Tags.dialMediaSink) {
throw new ReferenceError(
"MediaSinkExtraData.dialMediaSink is not currently set.");
}
return this.$data;
},
set: function(value) {
this.$tag = MediaSinkExtraData.Tags.dialMediaSink;
this.$data = value;
}
});
Object.defineProperty(MediaSinkExtraData.prototype, "castMediaSink", {
get: function() {
if (this.$tag != MediaSinkExtraData.Tags.castMediaSink) {
"MediaSinkExtraData.castMediaSink is not currently set.");
}
return this.$data;
},
this.$tag = MediaSinkExtraData.Tags.castMediaSink;
this.$data = value;
}
});
MediaSinkExtraData.encode = function(encoder, val) {

if (val == null) {
return;
}
if (val.$tag == undefined) {
throw new TypeError("Cannot encode unions with an unknown member set.");
}
encoder.writeUint32(val.$tag);
switch (val.$tag) {
case MediaSinkExtraData.Tags.dialMediaSink:
encoder.encodeStructPointer(DialMediaSink, val.dialMediaSink);
break;
case MediaSinkExtraData.Tags.castMediaSink:
encoder.encodeStructPointer(CastMediaSink, val.castMediaSink);
break;
}
encoder.align();
};
MediaSinkExtraData.decode = function(decoder) {
var size = decoder.readUint32();
if (size == 0) {
decoder.readUint32();
decoder.readUint64();
return null;
}
var result = new MediaSinkExtraData();

var tag = decoder.readUint32();
switch (tag) {
result.dialMediaSink = decoder.decodeStructPointer(DialMediaSink);
break;
result.castMediaSink = decoder.decodeStructPointer(CastMediaSink);
break;
}
decoder.align();
return result;
};
MediaSinkExtraData.validate = function(messageValidator, offset) {

var size = messageValidator.decodeUnionSize(offset);
if (size != 16) {
return validator.validationError.INVALID_UNION_SIZE;
}
var tag = messageValidator.decodeUnionTag(offset);

var data_offset = offset + 8;
var err;
switch (tag) {
// validate MediaSinkExtraData.dialMediaSink
err = messageValidator.validateStructPointer(data_offset, DialMediaSink,
false);
return err;
break;
// validate MediaSinkExtraData.castMediaSink
err = messageValidator.validateStructPointer(data_offset, CastMediaSink,
false);
return err;
break;
}
};
MediaSinkExtraData.encodedSize = 16;
var kMediaRouteProvider_CreateRoute_Name = 1248616479;
var kMediaRouteProvider_JoinRoute_Name = 666604304;
var kMediaRouteProvider_ConnectRouteByRouteId_Name = 1832351913;
var kMediaRouteProvider_TerminateRoute_Name = 1072955673;
var kMediaRouteProvider_SendRouteMessage_Name = 187331026;
var kMediaRouteProvider_SendRouteBinaryMessage_Name = 696089890;
var kMediaRouteProvider_StartObservingMediaSinks_Name = 438693357;
var kMediaRouteProvider_StopObservingMediaSinks_Name = 1096050803;
var kMediaRouteProvider_StartObservingMediaRoutes_Name = 638033226;
var kMediaRouteProvider_StopObservingMediaRoutes_Name = 665920907;
var kMediaRouteProvider_StartListeningForRouteMessages_Name = 1950404726;
var kMediaRouteProvider_StopListeningForRouteMessages_Name = 1940647994;
var kMediaRouteProvider_DetachRoute_Name = 274349381;
var kMediaRouteProvider_EnableMdnsDiscovery_Name = 993154287;
var kMediaRouteProvider_UpdateMediaSinks_Name = 1571616814;
var kMediaRouteProvider_SearchSinks_Name = 1988996693;
var kMediaRouteProvider_ProvideSinks_Name = 210491669;
var kMediaRouteProvider_CreateMediaRouteController_Name = 158190702;
function MediaRouteProviderPtr(handleOrPtrInfo) {
this.ptr = new bindings.InterfacePtrController(MediaRouteProvider,
handleOrPtrInfo);
}
function MediaRouteProviderAssociatedPtr(associatedInterfacePtrInfo) {
this.ptr = new associatedBindings.AssociatedInterfacePtrController(
MediaRouteProvider, associatedInterfacePtrInfo);
}
MediaRouteProviderAssociatedPtr.prototype =
Object.create(MediaRouteProviderPtr.prototype);
MediaRouteProviderAssociatedPtr.prototype.constructor =
MediaRouteProviderAssociatedPtr;
function MediaRouteProviderProxy(receiver) {
this.receiver_ = receiver;
}
MediaRouteProviderPtr.prototype.createRoute = function() {
return MediaRouteProviderProxy.prototype.createRoute
.apply(this.ptr.getProxy(), arguments);
};
MediaRouteProviderProxy.prototype.createRoute = function(mediaSource, sinkId,

originalPresentationId, origin, tabId, timeout, incognito) {
var params_ = new MediaRouteProvider_CreateRoute_Params();
params_.mediaSource = mediaSource;
params_.sinkId = sinkId;
params_.originalPresentationId = originalPresentationId;
params_.origin = origin;
params_.tabId = tabId;
params_.timeout = timeout;
params_.incognito = incognito;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
kMediaRouteProvider_CreateRoute_Name,
codec.align(MediaRouteProvider_CreateRoute_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
builder.encodeStruct(MediaRouteProvider_CreateRoute_Params, params_);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
reader.decodeStruct(MediaRouteProvider_CreateRoute_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
});
}.bind(this));
};
MediaRouteProviderPtr.prototype.joinRoute = function() {
return MediaRouteProviderProxy.prototype.joinRoute
};
MediaRouteProviderProxy.prototype.joinRoute = function(mediaSource,
presentationId, origin, tabId, timeout, incognito) {
var params_ = new MediaRouteProvider_JoinRoute_Params();
params_.presentationId = presentationId;
kMediaRouteProvider_JoinRoute_Name,
codec.align(MediaRouteProvider_JoinRoute_Params.encodedSize),
builder.encodeStruct(MediaRouteProvider_JoinRoute_Params, params_);
reader.decodeStruct(MediaRouteProvider_JoinRoute_ResponseParams);
});
}.bind(this));
};
MediaRouteProviderPtr.prototype.connectRouteByRouteId = function() {
return MediaRouteProviderProxy.prototype.connectRouteByRouteId
};
MediaRouteProviderProxy.prototype.connectRouteByRouteId = function(mediaSource,
routeId, presentationId, origin, tabId, timeout, incognito) {
var params_ = new MediaRouteProvider_ConnectRouteByRouteId_Params();
params_.routeId = routeId;
kMediaRouteProvider_ConnectRouteByRouteId_Name,
codec.align(MediaRouteProvider_ConnectRouteByRouteId_Params.encodedSize),
builder.encodeStruct(MediaRouteProvider_ConnectRouteByRouteId_Params,
params_);
reader.decodeStruct(MediaRouteProvider_ConnectRouteByRouteId_ResponseParams);
});
}.bind(this));
};
MediaRouteProviderPtr.prototype.terminateRoute = function() {
return MediaRouteProviderProxy.prototype.terminateRoute
};
MediaRouteProviderProxy.prototype.terminateRoute = function(routeId) {
var params_ = new MediaRouteProvider_TerminateRoute_Params();
kMediaRouteProvider_TerminateRoute_Name,
codec.align(MediaRouteProvider_TerminateRoute_Params.encodedSize),
builder.encodeStruct(MediaRouteProvider_TerminateRoute_Params, params_);
reader.decodeStruct(MediaRouteProvider_TerminateRoute_ResponseParams);
});
}.bind(this));
};
MediaRouteProviderPtr.prototype.sendRouteMessage = function() {
return MediaRouteProviderProxy.prototype.sendRouteMessage
};
MediaRouteProviderProxy.prototype.sendRouteMessage = function(mediaRouteId,
message) {
var params_ = new MediaRouteProvider_SendRouteMessage_Params();
params_.mediaRouteId = mediaRouteId;
params_.message = message;
kMediaRouteProvider_SendRouteMessage_Name,
codec.align(MediaRouteProvider_SendRouteMessage_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_SendRouteMessage_Params, params_);
this.receiver_.accept(message);
};
MediaRouteProviderPtr.prototype.sendRouteBinaryMessage = function() {
return MediaRouteProviderProxy.prototype.sendRouteBinaryMessage
};
MediaRouteProviderProxy.prototype.sendRouteBinaryMessage = function(mediaRouteId,
data) {
var params_ = new MediaRouteProvider_SendRouteBinaryMessage_Params();
params_.mediaRouteId = mediaRouteId;
params_.data = data;
kMediaRouteProvider_SendRouteBinaryMessage_Name,
codec.align(MediaRouteProvider_SendRouteBinaryMessage_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_SendRouteBinaryMessage_Params,
params_);
};
MediaRouteProviderPtr.prototype.startObservingMediaSinks = function() {
return MediaRouteProviderProxy.prototype.startObservingMediaSinks
};
MediaRouteProviderProxy.prototype.startObservingMediaSinks =
function(mediaSource) {
var params_ = new MediaRouteProvider_StartObservingMediaSinks_Params();
kMediaRouteProvider_StartObservingMediaSinks_Name,
codec.align(MediaRouteProvider_StartObservingMediaSinks_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_StartObservingMediaSinks_Params,
params_);
};
MediaRouteProviderPtr.prototype.stopObservingMediaSinks = function() {
return MediaRouteProviderProxy.prototype.stopObservingMediaSinks
};
MediaRouteProviderProxy.prototype.stopObservingMediaSinks = function(mediaSource)
{
var params_ = new MediaRouteProvider_StopObservingMediaSinks_Params();
kMediaRouteProvider_StopObservingMediaSinks_Name,
codec.align(MediaRouteProvider_StopObservingMediaSinks_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_StopObservingMediaSinks_Params,
params_);
};
MediaRouteProviderPtr.prototype.startObservingMediaRoutes = function() {
return MediaRouteProviderProxy.prototype.startObservingMediaRoutes
};
MediaRouteProviderProxy.prototype.startObservingMediaRoutes =
var params_ = new MediaRouteProvider_StartObservingMediaRoutes_Params();
kMediaRouteProvider_StartObservingMediaRoutes_Name,
codec.align(MediaRouteProvider_StartObservingMediaRoutes_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_StartObservingMediaRoutes_Params,
params_);
};
MediaRouteProviderPtr.prototype.stopObservingMediaRoutes = function() {
return MediaRouteProviderProxy.prototype.stopObservingMediaRoutes
};
MediaRouteProviderProxy.prototype.stopObservingMediaRoutes =
var params_ = new MediaRouteProvider_StopObservingMediaRoutes_Params();
kMediaRouteProvider_StopObservingMediaRoutes_Name,
codec.align(MediaRouteProvider_StopObservingMediaRoutes_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_StopObservingMediaRoutes_Params,
params_);
};
MediaRouteProviderPtr.prototype.startListeningForRouteMessages = function() {
return MediaRouteProviderProxy.prototype.startListeningForRouteMessages
};
MediaRouteProviderProxy.prototype.startListeningForRouteMessages =
function(routeId) {
var params_ = new MediaRouteProvider_StartListeningForRouteMessages_Params();
kMediaRouteProvider_StartListeningForRouteMessages_Name,
codec.align(MediaRouteProvider_StartListeningForRouteMessages_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_StartListeningForRouteMessages_Params,
params_);
};
MediaRouteProviderPtr.prototype.stopListeningForRouteMessages = function() {
return MediaRouteProviderProxy.prototype.stopListeningForRouteMessages
};
MediaRouteProviderProxy.prototype.stopListeningForRouteMessages =
function(routeId) {
var params_ = new MediaRouteProvider_StopListeningForRouteMessages_Params();
kMediaRouteProvider_StopListeningForRouteMessages_Name,
codec.align(MediaRouteProvider_StopListeningForRouteMessages_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_StopListeningForRouteMessages_Params,
params_);
};
MediaRouteProviderPtr.prototype.detachRoute = function() {
return MediaRouteProviderProxy.prototype.detachRoute
};
MediaRouteProviderProxy.prototype.detachRoute = function(routeId) {
var params_ = new MediaRouteProvider_DetachRoute_Params();
kMediaRouteProvider_DetachRoute_Name,
codec.align(MediaRouteProvider_DetachRoute_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_DetachRoute_Params, params_);
};
MediaRouteProviderPtr.prototype.enableMdnsDiscovery = function() {
return MediaRouteProviderProxy.prototype.enableMdnsDiscovery
};
MediaRouteProviderProxy.prototype.enableMdnsDiscovery = function() {
var params_ = new MediaRouteProvider_EnableMdnsDiscovery_Params();
kMediaRouteProvider_EnableMdnsDiscovery_Name,
codec.align(MediaRouteProvider_EnableMdnsDiscovery_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_EnableMdnsDiscovery_Params, params_);
};
MediaRouteProviderPtr.prototype.updateMediaSinks = function() {
return MediaRouteProviderProxy.prototype.updateMediaSinks
};
MediaRouteProviderProxy.prototype.updateMediaSinks = function(mediaSource) {
var params_ = new MediaRouteProvider_UpdateMediaSinks_Params();
kMediaRouteProvider_UpdateMediaSinks_Name,
codec.align(MediaRouteProvider_UpdateMediaSinks_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_UpdateMediaSinks_Params, params_);
};
MediaRouteProviderPtr.prototype.searchSinks = function() {
return MediaRouteProviderProxy.prototype.searchSinks
};
MediaRouteProviderProxy.prototype.searchSinks = function(sinkId, mediaSource,

searchCriteria) {
var params_ = new MediaRouteProvider_SearchSinks_Params();
params_.sinkId = sinkId;
params_.searchCriteria = searchCriteria;
kMediaRouteProvider_SearchSinks_Name,
codec.align(MediaRouteProvider_SearchSinks_Params.encodedSize),
builder.encodeStruct(MediaRouteProvider_SearchSinks_Params, params_);
reader.decodeStruct(MediaRouteProvider_SearchSinks_ResponseParams);
});
}.bind(this));
};
MediaRouteProviderPtr.prototype.provideSinks = function() {
return MediaRouteProviderProxy.prototype.provideSinks
};
MediaRouteProviderProxy.prototype.provideSinks = function(providerName, sinks) {

var params_ = new MediaRouteProvider_ProvideSinks_Params();
params_.providerName = providerName;
params_.sinks = sinks;
kMediaRouteProvider_ProvideSinks_Name,
codec.align(MediaRouteProvider_ProvideSinks_Params.encodedSize));
builder.encodeStruct(MediaRouteProvider_ProvideSinks_Params, params_);
};
MediaRouteProviderPtr.prototype.createMediaRouteController = function() {
return MediaRouteProviderProxy.prototype.createMediaRouteController
};
MediaRouteProviderProxy.prototype.createMediaRouteController = function(routeId,
mediaController, observer) {
var params_ = new MediaRouteProvider_CreateMediaRouteController_Params();
params_.mediaController = mediaController;
params_.observer = observer;
kMediaRouteProvider_CreateMediaRouteController_Name,
codec.align(MediaRouteProvider_CreateMediaRouteController_Params.encodedSize),
builder.encodeStruct(MediaRouteProvider_CreateMediaRouteController_Params,
params_);
reader.decodeStruct(MediaRouteProvider_CreateMediaRouteController_ResponseParams);
});
}.bind(this));
};
function MediaRouteProviderStub(delegate) {
this.delegate_ = delegate;
}
MediaRouteProviderStub.prototype.createRoute = function(mediaSource, sinkId,
originalPresentationId, origin, tabId, timeout, incognito) {
return this.delegate_ && this.delegate_.createRoute &&
this.delegate_.createRoute(mediaSource, sinkId, originalPresentationId, origin,
tabId, timeout, incognito);
}
MediaRouteProviderStub.prototype.joinRoute = function(mediaSource,
presentationId, origin, tabId, timeout, incognito) {
return this.delegate_ && this.delegate_.joinRoute &&
this.delegate_.joinRoute(mediaSource, presentationId, origin, tabId, timeout,
incognito);
}
MediaRouteProviderStub.prototype.connectRouteByRouteId = function(mediaSource,
routeId, presentationId, origin, tabId, timeout, incognito) {
return this.delegate_ && this.delegate_.connectRouteByRouteId &&
this.delegate_.connectRouteByRouteId(mediaSource, routeId, presentationId, origin,
tabId, timeout, incognito);
}
MediaRouteProviderStub.prototype.terminateRoute = function(routeId) {
return this.delegate_ && this.delegate_.terminateRoute &&
this.delegate_.terminateRoute(routeId);
}
MediaRouteProviderStub.prototype.sendRouteMessage = function(mediaRouteId,
message) {
return this.delegate_ && this.delegate_.sendRouteMessage &&
this.delegate_.sendRouteMessage(mediaRouteId, message);
}
MediaRouteProviderStub.prototype.sendRouteBinaryMessage = function(mediaRouteId,
data) {
return this.delegate_ && this.delegate_.sendRouteBinaryMessage &&
this.delegate_.sendRouteBinaryMessage(mediaRouteId, data);
}
MediaRouteProviderStub.prototype.startObservingMediaSinks = function(mediaSource)
{
return this.delegate_ && this.delegate_.startObservingMediaSinks &&
this.delegate_.startObservingMediaSinks(mediaSource);
}
MediaRouteProviderStub.prototype.stopObservingMediaSinks = function(mediaSource)
{
return this.delegate_ && this.delegate_.stopObservingMediaSinks &&
this.delegate_.stopObservingMediaSinks(mediaSource);
}
MediaRouteProviderStub.prototype.startObservingMediaRoutes =
return this.delegate_ && this.delegate_.startObservingMediaRoutes &&
this.delegate_.startObservingMediaRoutes(mediaSource);
}
MediaRouteProviderStub.prototype.stopObservingMediaRoutes = function(mediaSource)
{
return this.delegate_ && this.delegate_.stopObservingMediaRoutes &&
this.delegate_.stopObservingMediaRoutes(mediaSource);
}
MediaRouteProviderStub.prototype.startListeningForRouteMessages =
function(routeId) {
return this.delegate_ && this.delegate_.startListeningForRouteMessages &&
this.delegate_.startListeningForRouteMessages(routeId);
}
MediaRouteProviderStub.prototype.stopListeningForRouteMessages =
function(routeId) {
return this.delegate_ && this.delegate_.stopListeningForRouteMessages &&
this.delegate_.stopListeningForRouteMessages(routeId);
}
MediaRouteProviderStub.prototype.detachRoute = function(routeId) {
return this.delegate_ && this.delegate_.detachRoute &&
this.delegate_.detachRoute(routeId);
}
MediaRouteProviderStub.prototype.enableMdnsDiscovery = function() {
return this.delegate_ && this.delegate_.enableMdnsDiscovery &&
this.delegate_.enableMdnsDiscovery();
}
MediaRouteProviderStub.prototype.updateMediaSinks = function(mediaSource) {
return this.delegate_ && this.delegate_.updateMediaSinks &&
this.delegate_.updateMediaSinks(mediaSource);
}
MediaRouteProviderStub.prototype.searchSinks = function(sinkId, mediaSource,
searchCriteria) {
return this.delegate_ && this.delegate_.searchSinks &&
this.delegate_.searchSinks(sinkId, mediaSource, searchCriteria);
}
MediaRouteProviderStub.prototype.provideSinks = function(providerName, sinks) {
return this.delegate_ && this.delegate_.provideSinks &&
this.delegate_.provideSinks(providerName, sinks);
}
MediaRouteProviderStub.prototype.createMediaRouteController = function(routeId,
mediaController, observer) {
return this.delegate_ && this.delegate_.createMediaRouteController &&
this.delegate_.createMediaRouteController(routeId, mediaController, observer);
}
MediaRouteProviderStub.prototype.accept = function(message) {
switch (reader.messageName) {
case kMediaRouteProvider_SendRouteMessage_Name:
var params = reader.decodeStruct(MediaRouteProvider_SendRouteMessage_Params);
this.sendRouteMessage(params.mediaRouteId, params.message);
return true;
case kMediaRouteProvider_SendRouteBinaryMessage_Name:
var params =
reader.decodeStruct(MediaRouteProvider_SendRouteBinaryMessage_Params);
this.sendRouteBinaryMessage(params.mediaRouteId, params.data);
return true;
case kMediaRouteProvider_StartObservingMediaSinks_Name:
var params =
reader.decodeStruct(MediaRouteProvider_StartObservingMediaSinks_Params);
this.startObservingMediaSinks(params.mediaSource);
return true;
case kMediaRouteProvider_StopObservingMediaSinks_Name:
var params =
reader.decodeStruct(MediaRouteProvider_StopObservingMediaSinks_Params);
this.stopObservingMediaSinks(params.mediaSource);
return true;
case kMediaRouteProvider_StartObservingMediaRoutes_Name:
var params =
reader.decodeStruct(MediaRouteProvider_StartObservingMediaRoutes_Params);
this.startObservingMediaRoutes(params.mediaSource);
return true;
case kMediaRouteProvider_StopObservingMediaRoutes_Name:
var params =
reader.decodeStruct(MediaRouteProvider_StopObservingMediaRoutes_Params);
this.stopObservingMediaRoutes(params.mediaSource);
return true;
case kMediaRouteProvider_StartListeningForRouteMessages_Name:
var params =
reader.decodeStruct(MediaRouteProvider_StartListeningForRouteMessages_Params);
this.startListeningForRouteMessages(params.routeId);
return true;
case kMediaRouteProvider_StopListeningForRouteMessages_Name:
var params =
reader.decodeStruct(MediaRouteProvider_StopListeningForRouteMessages_Params);
this.stopListeningForRouteMessages(params.routeId);
return true;
case kMediaRouteProvider_DetachRoute_Name:
var params = reader.decodeStruct(MediaRouteProvider_DetachRoute_Params);
this.detachRoute(params.routeId);
return true;
case kMediaRouteProvider_EnableMdnsDiscovery_Name:
var params =
reader.decodeStruct(MediaRouteProvider_EnableMdnsDiscovery_Params);
this.enableMdnsDiscovery();
return true;
case kMediaRouteProvider_UpdateMediaSinks_Name:
var params = reader.decodeStruct(MediaRouteProvider_UpdateMediaSinks_Params);
this.updateMediaSinks(params.mediaSource);
return true;
case kMediaRouteProvider_ProvideSinks_Name:
var params = reader.decodeStruct(MediaRouteProvider_ProvideSinks_Params);
this.provideSinks(params.providerName, params.sinks);
return true;
default:
return false;
}
};
MediaRouteProviderStub.prototype.acceptWithResponder =
function(message, responder) {
case kMediaRouteProvider_CreateRoute_Name:
var params = reader.decodeStruct(MediaRouteProvider_CreateRoute_Params);
this.createRoute(params.mediaSource, params.sinkId,
params.originalPresentationId, params.origin, params.tabId, params.timeout,
params.incognito).then(function(response) {
new MediaRouteProvider_CreateRoute_ResponseParams();
responseParams.route = response.route;
responseParams.connection = response.connection;
responseParams.errorText = response.errorText;
responseParams.resultCode = response.resultCode;
kMediaRouteProvider_CreateRoute_Name,
codec.align(MediaRouteProvider_CreateRoute_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
builder.encodeStruct(MediaRouteProvider_CreateRoute_ResponseParams,
responseParams);
responder.accept(message);
});
return true;
case kMediaRouteProvider_JoinRoute_Name:
var params = reader.decodeStruct(MediaRouteProvider_JoinRoute_Params);
this.joinRoute(params.mediaSource, params.presentationId, params.origin,
params.tabId, params.timeout, params.incognito).then(function(response) {
new MediaRouteProvider_JoinRoute_ResponseParams();
kMediaRouteProvider_JoinRoute_Name,
codec.align(MediaRouteProvider_JoinRoute_ResponseParams.encodedSize),
builder.encodeStruct(MediaRouteProvider_JoinRoute_ResponseParams,
responseParams);
});
return true;
case kMediaRouteProvider_ConnectRouteByRouteId_Name:
var params =
reader.decodeStruct(MediaRouteProvider_ConnectRouteByRouteId_Params);
this.connectRouteByRouteId(params.mediaSource, params.routeId,
params.presentationId, params.origin, params.tabId, params.timeout,
params.incognito).then(function(response) {
new MediaRouteProvider_ConnectRouteByRouteId_ResponseParams();
kMediaRouteProvider_ConnectRouteByRouteId_Name,
codec.align(MediaRouteProvider_ConnectRouteByRouteId_ResponseParams.encodedSize),
builder.encodeStruct(MediaRouteProvider_ConnectRouteByRouteId_ResponseParams,
responseParams);
});
return true;
case kMediaRouteProvider_TerminateRoute_Name:
var params = reader.decodeStruct(MediaRouteProvider_TerminateRoute_Params);
this.terminateRoute(params.routeId).then(function(response) {
new MediaRouteProvider_TerminateRoute_ResponseParams();
kMediaRouteProvider_TerminateRoute_Name,
codec.align(MediaRouteProvider_TerminateRoute_ResponseParams.encodedSize),
builder.encodeStruct(MediaRouteProvider_TerminateRoute_ResponseParams,
responseParams);
});
return true;
case kMediaRouteProvider_SearchSinks_Name:
var params = reader.decodeStruct(MediaRouteProvider_SearchSinks_Params);
this.searchSinks(params.sinkId, params.mediaSource,
params.searchCriteria).then(function(response) {
new MediaRouteProvider_SearchSinks_ResponseParams();
responseParams.sinkId = response.sinkId;
kMediaRouteProvider_SearchSinks_Name,
codec.align(MediaRouteProvider_SearchSinks_ResponseParams.encodedSize),
builder.encodeStruct(MediaRouteProvider_SearchSinks_ResponseParams,
responseParams);
});
return true;
case kMediaRouteProvider_CreateMediaRouteController_Name:
var params =
reader.decodeStruct(MediaRouteProvider_CreateMediaRouteController_Params);
this.createMediaRouteController(params.routeId, params.mediaController,
params.observer).then(function(response) {
new MediaRouteProvider_CreateMediaRouteController_ResponseParams();
responseParams.success = response.success;
kMediaRouteProvider_CreateMediaRouteController_Name,
codec.align(MediaRouteProvider_CreateMediaRouteController_ResponseParams.encodedSiz
e),
builder.encodeStruct(MediaRouteProvider_CreateMediaRouteController_ResponseParams,
responseParams);
});
return true;
default:
return false;
}
};
function validateMediaRouteProviderRequest(messageValidator) {
var message = messageValidator.message;
var paramsClass = null;
switch (message.getName()) {
if (message.expectsResponse())
paramsClass = MediaRouteProvider_CreateRoute_Params;
break;
paramsClass = MediaRouteProvider_JoinRoute_Params;
break;
paramsClass = MediaRouteProvider_ConnectRouteByRouteId_Params;
break;
paramsClass = MediaRouteProvider_TerminateRoute_Params;
break;
case kMediaRouteProvider_SendRouteMessage_Name:
if (!message.expectsResponse() && !message.isResponse())
paramsClass = MediaRouteProvider_SendRouteMessage_Params;
break;
case kMediaRouteProvider_SendRouteBinaryMessage_Name:
paramsClass = MediaRouteProvider_SendRouteBinaryMessage_Params;
break;
case kMediaRouteProvider_StartObservingMediaSinks_Name:
paramsClass = MediaRouteProvider_StartObservingMediaSinks_Params;
break;
case kMediaRouteProvider_StopObservingMediaSinks_Name:
paramsClass = MediaRouteProvider_StopObservingMediaSinks_Params;
break;
case kMediaRouteProvider_StartObservingMediaRoutes_Name:
paramsClass = MediaRouteProvider_StartObservingMediaRoutes_Params;
break;
case kMediaRouteProvider_StopObservingMediaRoutes_Name:
paramsClass = MediaRouteProvider_StopObservingMediaRoutes_Params;
break;
case kMediaRouteProvider_StartListeningForRouteMessages_Name:
paramsClass = MediaRouteProvider_StartListeningForRouteMessages_Params;
break;
case kMediaRouteProvider_StopListeningForRouteMessages_Name:
paramsClass = MediaRouteProvider_StopListeningForRouteMessages_Params;
break;
case kMediaRouteProvider_DetachRoute_Name:
paramsClass = MediaRouteProvider_DetachRoute_Params;
break;
case kMediaRouteProvider_EnableMdnsDiscovery_Name:
paramsClass = MediaRouteProvider_EnableMdnsDiscovery_Params;
break;
case kMediaRouteProvider_UpdateMediaSinks_Name:
paramsClass = MediaRouteProvider_UpdateMediaSinks_Params;
break;
paramsClass = MediaRouteProvider_SearchSinks_Params;
break;
case kMediaRouteProvider_ProvideSinks_Name:
paramsClass = MediaRouteProvider_ProvideSinks_Params;
break;
paramsClass = MediaRouteProvider_CreateMediaRouteController_Params;
break;
}
if (paramsClass === null)
return paramsClass.validate(messageValidator,
messageValidator.message.getHeaderNumBytes());
}
function validateMediaRouteProviderResponse(messageValidator) {
if (message.isResponse())
paramsClass = MediaRouteProvider_CreateRoute_ResponseParams;
break;
paramsClass = MediaRouteProvider_JoinRoute_ResponseParams;
break;
paramsClass = MediaRouteProvider_ConnectRouteByRouteId_ResponseParams;
break;
paramsClass = MediaRouteProvider_TerminateRoute_ResponseParams;
break;
paramsClass = MediaRouteProvider_SearchSinks_ResponseParams;
break;
paramsClass =
MediaRouteProvider_CreateMediaRouteController_ResponseParams;
break;
}
}
var MediaRouteProvider = {
name: 'media_router.mojom.MediaRouteProvider',
kVersion: 0,
ptrClass: MediaRouteProviderPtr,
proxyClass: MediaRouteProviderProxy,
stubClass: MediaRouteProviderStub,
validateRequest: validateMediaRouteProviderRequest,
validateResponse: validateMediaRouteProviderResponse,
};
MediaRouteProvider.Id = {};
MediaRouteProvider.Id.EXTENSION = 0;
MediaRouteProvider.Id.WIRED_DISPLAY = MediaRouteProvider.Id.EXTENSION + 1;
MediaRouteProvider.Id.CAST = MediaRouteProvider.Id.WIRED_DISPLAY + 1;
MediaRouteProvider.Id.DIAL = MediaRouteProvider.Id.CAST + 1;
MediaRouteProvider.Id.MIN_VALUE = 0,
MediaRouteProvider.Id.MAX_VALUE = 3,
MediaRouteProvider.Id.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
}
return false;
};
MediaRouteProvider.Id.validate = function(enumValue) {
var isExtensible = false;
if (isExtensible || this.isKnownEnumValue(enumValue))
return validator.validationError.UNKNOWN_ENUM_VALUE;
};
MediaRouteProviderStub.prototype.validator = validateMediaRouteProviderRequest;
MediaRouteProviderProxy.prototype.validator = validateMediaRouteProviderResponse;
var kMediaRouter_RegisterMediaRouteProvider_Name = 731041617;
var kMediaRouter_OnSinksReceived_Name = 1592541233;
var kMediaRouter_OnIssue_Name = 1222971274;
var kMediaRouter_OnRoutesUpdated_Name = 2145895223;
var kMediaRouter_OnSinkAvailabilityUpdated_Name = 2008679052;
var kMediaRouter_OnPresentationConnectionStateChanged_Name = 1508444382;
var kMediaRouter_OnPresentationConnectionClosed_Name = 1811234766;
var kMediaRouter_OnRouteMessagesReceived_Name = 1285441556;
var kMediaRouter_OnMediaRemoterCreated_Name = 569122560;
var kMediaRouter_GetMediaSinkServiceStatus_Name = 325569508;
var kMediaRouter_GetMirroringServiceHostForTab_Name = 682527558;
var kMediaRouter_GetMirroringServiceHostForDesktop_Name = 2137587010;
var kMediaRouter_GetMirroringServiceHostForOffscreenTab_Name = 2037733877;
function MediaRouterPtr(handleOrPtrInfo) {
this.ptr = new bindings.InterfacePtrController(MediaRouter,
handleOrPtrInfo);
}
function MediaRouterAssociatedPtr(associatedInterfacePtrInfo) {
this.ptr = new associatedBindings.AssociatedInterfacePtrController(
MediaRouter, associatedInterfacePtrInfo);
}
MediaRouterAssociatedPtr.prototype =
Object.create(MediaRouterPtr.prototype);
MediaRouterAssociatedPtr.prototype.constructor =
MediaRouterAssociatedPtr;
function MediaRouterProxy(receiver) {
this.receiver_ = receiver;
}
MediaRouterPtr.prototype.registerMediaRouteProvider = function() {
return MediaRouterProxy.prototype.registerMediaRouteProvider
};
MediaRouterProxy.prototype.registerMediaRouteProvider = function(providerId,
mediaRouterProvider) {
var params_ = new MediaRouter_RegisterMediaRouteProvider_Params();
params_.providerId = providerId;
params_.mediaRouterProvider = mediaRouterProvider;
kMediaRouter_RegisterMediaRouteProvider_Name,
codec.align(MediaRouter_RegisterMediaRouteProvider_Params.encodedSize),
builder.encodeStruct(MediaRouter_RegisterMediaRouteProvider_Params, params_);
reader.decodeStruct(MediaRouter_RegisterMediaRouteProvider_ResponseParams);
});
}.bind(this));
};
MediaRouterPtr.prototype.onSinksReceived = function() {
return MediaRouterProxy.prototype.onSinksReceived
};
MediaRouterProxy.prototype.onSinksReceived = function(providerId, mediaSource,

sinks, origins) {
var params_ = new MediaRouter_OnSinksReceived_Params();
params_.sinks = sinks;
params_.origins = origins;
kMediaRouter_OnSinksReceived_Name,
codec.align(MediaRouter_OnSinksReceived_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnSinksReceived_Params, params_);
};
MediaRouterPtr.prototype.onIssue = function() {
return MediaRouterProxy.prototype.onIssue
};
MediaRouterProxy.prototype.onIssue = function(issue) {
var params_ = new MediaRouter_OnIssue_Params();
params_.issue = issue;
kMediaRouter_OnIssue_Name,
codec.align(MediaRouter_OnIssue_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnIssue_Params, params_);
};
MediaRouterPtr.prototype.onRoutesUpdated = function() {
return MediaRouterProxy.prototype.onRoutesUpdated
};
MediaRouterProxy.prototype.onRoutesUpdated = function(providerId, routes,

mediaSource, joinableRouteIds) {
var params_ = new MediaRouter_OnRoutesUpdated_Params();
params_.routes = routes;
params_.joinableRouteIds = joinableRouteIds;
kMediaRouter_OnRoutesUpdated_Name,
codec.align(MediaRouter_OnRoutesUpdated_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnRoutesUpdated_Params, params_);
};
MediaRouterPtr.prototype.onSinkAvailabilityUpdated = function() {
return MediaRouterProxy.prototype.onSinkAvailabilityUpdated
};
MediaRouterProxy.prototype.onSinkAvailabilityUpdated = function(providerId,
availability) {
var params_ = new MediaRouter_OnSinkAvailabilityUpdated_Params();
params_.availability = availability;
kMediaRouter_OnSinkAvailabilityUpdated_Name,
codec.align(MediaRouter_OnSinkAvailabilityUpdated_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnSinkAvailabilityUpdated_Params, params_);
};
MediaRouterPtr.prototype.onPresentationConnectionStateChanged = function() {
return MediaRouterProxy.prototype.onPresentationConnectionStateChanged
};
MediaRouterProxy.prototype.onPresentationConnectionStateChanged =
function(routeId, state) {
var params_ = new MediaRouter_OnPresentationConnectionStateChanged_Params();
params_.state = state;
kMediaRouter_OnPresentationConnectionStateChanged_Name,
codec.align(MediaRouter_OnPresentationConnectionStateChanged_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnPresentationConnectionStateChanged_Params,
params_);
};
MediaRouterPtr.prototype.onPresentationConnectionClosed = function() {
return MediaRouterProxy.prototype.onPresentationConnectionClosed
};
MediaRouterProxy.prototype.onPresentationConnectionClosed = function(routeId,
reason, message) {
var params_ = new MediaRouter_OnPresentationConnectionClosed_Params();
params_.reason = reason;
params_.message = message;
kMediaRouter_OnPresentationConnectionClosed_Name,
codec.align(MediaRouter_OnPresentationConnectionClosed_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnPresentationConnectionClosed_Params,
params_);
};
MediaRouterPtr.prototype.onRouteMessagesReceived = function() {
return MediaRouterProxy.prototype.onRouteMessagesReceived
};
MediaRouterProxy.prototype.onRouteMessagesReceived = function(routeId, messages)

{
var params_ = new MediaRouter_OnRouteMessagesReceived_Params();
params_.messages = messages;
kMediaRouter_OnRouteMessagesReceived_Name,
codec.align(MediaRouter_OnRouteMessagesReceived_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnRouteMessagesReceived_Params, params_);
};
MediaRouterPtr.prototype.onMediaRemoterCreated = function() {
return MediaRouterProxy.prototype.onMediaRemoterCreated
};
MediaRouterProxy.prototype.onMediaRemoterCreated = function(tabId, remoter,

remotingSource) {
var params_ = new MediaRouter_OnMediaRemoterCreated_Params();
params_.remoter = remoter;
params_.remotingSource = remotingSource;
kMediaRouter_OnMediaRemoterCreated_Name,
codec.align(MediaRouter_OnMediaRemoterCreated_Params.encodedSize));
builder.encodeStruct(MediaRouter_OnMediaRemoterCreated_Params, params_);
};
MediaRouterPtr.prototype.getMediaSinkServiceStatus = function() {
return MediaRouterProxy.prototype.getMediaSinkServiceStatus
};
MediaRouterProxy.prototype.getMediaSinkServiceStatus = function() {
var params_ = new MediaRouter_GetMediaSinkServiceStatus_Params();
kMediaRouter_GetMediaSinkServiceStatus_Name,
codec.align(MediaRouter_GetMediaSinkServiceStatus_Params.encodedSize),
builder.encodeStruct(MediaRouter_GetMediaSinkServiceStatus_Params, params_);
reader.decodeStruct(MediaRouter_GetMediaSinkServiceStatus_ResponseParams);
});
}.bind(this));
};
MediaRouterPtr.prototype.getMirroringServiceHostForTab = function() {
return MediaRouterProxy.prototype.getMirroringServiceHostForTab
};
MediaRouterProxy.prototype.getMirroringServiceHostForTab = function(targetTabId,
request) {
var params_ = new MediaRouter_GetMirroringServiceHostForTab_Params();
params_.targetTabId = targetTabId;
params_.request = request;
kMediaRouter_GetMirroringServiceHostForTab_Name,
codec.align(MediaRouter_GetMirroringServiceHostForTab_Params.encodedSize));
builder.encodeStruct(MediaRouter_GetMirroringServiceHostForTab_Params,
params_);
};
MediaRouterPtr.prototype.getMirroringServiceHostForDesktop = function() {
return MediaRouterProxy.prototype.getMirroringServiceHostForDesktop
};
MediaRouterProxy.prototype.getMirroringServiceHostForDesktop =
function(initiatorTabId, desktopStreamId, request) {
var params_ = new MediaRouter_GetMirroringServiceHostForDesktop_Params();
params_.initiatorTabId = initiatorTabId;
params_.desktopStreamId = desktopStreamId;
kMediaRouter_GetMirroringServiceHostForDesktop_Name,
codec.align(MediaRouter_GetMirroringServiceHostForDesktop_Params.encodedSize));
builder.encodeStruct(MediaRouter_GetMirroringServiceHostForDesktop_Params,
params_);
};
MediaRouterPtr.prototype.getMirroringServiceHostForOffscreenTab = function() {
return MediaRouterProxy.prototype.getMirroringServiceHostForOffscreenTab
};
MediaRouterProxy.prototype.getMirroringServiceHostForOffscreenTab =
function(presentationUrl, presentationId, request) {
var params_ = new MediaRouter_GetMirroringServiceHostForOffscreenTab_Params();
params_.presentationUrl = presentationUrl;
kMediaRouter_GetMirroringServiceHostForOffscreenTab_Name,
codec.align(MediaRouter_GetMirroringServiceHostForOffscreenTab_Params.encodedSize))
;
builder.encodeStruct(MediaRouter_GetMirroringServiceHostForOffscreenTab_Params,
params_);
};
function MediaRouterStub(delegate) {
}
MediaRouterStub.prototype.registerMediaRouteProvider = function(providerId,
mediaRouterProvider) {
return this.delegate_ && this.delegate_.registerMediaRouteProvider &&
this.delegate_.registerMediaRouteProvider(providerId, mediaRouterProvider);
}
MediaRouterStub.prototype.onSinksReceived = function(providerId, mediaSource,
sinks, origins) {
return this.delegate_ && this.delegate_.onSinksReceived &&
this.delegate_.onSinksReceived(providerId, mediaSource, sinks, origins);
}
MediaRouterStub.prototype.onIssue = function(issue) {
return this.delegate_ && this.delegate_.onIssue &&
this.delegate_.onIssue(issue);
}
MediaRouterStub.prototype.onRoutesUpdated = function(providerId, routes,
mediaSource, joinableRouteIds) {
return this.delegate_ && this.delegate_.onRoutesUpdated &&
this.delegate_.onRoutesUpdated(providerId, routes, mediaSource, joinableRouteIds);
}
MediaRouterStub.prototype.onSinkAvailabilityUpdated = function(providerId,
availability) {
return this.delegate_ && this.delegate_.onSinkAvailabilityUpdated &&
this.delegate_.onSinkAvailabilityUpdated(providerId, availability);
}
MediaRouterStub.prototype.onPresentationConnectionStateChanged =
function(routeId, state) {
return this.delegate_ && this.delegate_.onPresentationConnectionStateChanged &&
this.delegate_.onPresentationConnectionStateChanged(routeId, state);
}
MediaRouterStub.prototype.onPresentationConnectionClosed = function(routeId,
reason, message) {
return this.delegate_ && this.delegate_.onPresentationConnectionClosed &&
this.delegate_.onPresentationConnectionClosed(routeId, reason, message);
}
MediaRouterStub.prototype.onRouteMessagesReceived = function(routeId, messages) {
return this.delegate_ && this.delegate_.onRouteMessagesReceived &&
this.delegate_.onRouteMessagesReceived(routeId, messages);
}
MediaRouterStub.prototype.onMediaRemoterCreated = function(tabId, remoter,
remotingSource) {
return this.delegate_ && this.delegate_.onMediaRemoterCreated &&
this.delegate_.onMediaRemoterCreated(tabId, remoter, remotingSource);
}
MediaRouterStub.prototype.getMediaSinkServiceStatus = function() {
return this.delegate_ && this.delegate_.getMediaSinkServiceStatus &&
this.delegate_.getMediaSinkServiceStatus();
}
MediaRouterStub.prototype.getMirroringServiceHostForTab = function(targetTabId,
request) {
return this.delegate_ && this.delegate_.getMirroringServiceHostForTab &&
this.delegate_.getMirroringServiceHostForTab(targetTabId, request);
}
MediaRouterStub.prototype.getMirroringServiceHostForDesktop =
function(initiatorTabId, desktopStreamId, request) {
return this.delegate_ && this.delegate_.getMirroringServiceHostForDesktop &&
this.delegate_.getMirroringServiceHostForDesktop(initiatorTabId, desktopStreamId,
request);
}
MediaRouterStub.prototype.getMirroringServiceHostForOffscreenTab =
function(presentationUrl, presentationId, request) {
return this.delegate_ && this.delegate_.getMirroringServiceHostForOffscreenTab
&& this.delegate_.getMirroringServiceHostForOffscreenTab(presentationUrl,
presentationId, request);
}
MediaRouterStub.prototype.accept = function(message) {
case kMediaRouter_OnSinksReceived_Name:
var params = reader.decodeStruct(MediaRouter_OnSinksReceived_Params);
this.onSinksReceived(params.providerId, params.mediaSource, params.sinks,
params.origins);
return true;
case kMediaRouter_OnIssue_Name:
var params = reader.decodeStruct(MediaRouter_OnIssue_Params);
this.onIssue(params.issue);
return true;
case kMediaRouter_OnRoutesUpdated_Name:
var params = reader.decodeStruct(MediaRouter_OnRoutesUpdated_Params);
this.onRoutesUpdated(params.providerId, params.routes, params.mediaSource,
params.joinableRouteIds);
return true;
case kMediaRouter_OnSinkAvailabilityUpdated_Name:
var params =
reader.decodeStruct(MediaRouter_OnSinkAvailabilityUpdated_Params);
this.onSinkAvailabilityUpdated(params.providerId, params.availability);
return true;
case kMediaRouter_OnPresentationConnectionStateChanged_Name:
var params =
reader.decodeStruct(MediaRouter_OnPresentationConnectionStateChanged_Params);
this.onPresentationConnectionStateChanged(params.routeId, params.state);
return true;
case kMediaRouter_OnPresentationConnectionClosed_Name:
var params =
reader.decodeStruct(MediaRouter_OnPresentationConnectionClosed_Params);
this.onPresentationConnectionClosed(params.routeId, params.reason,
params.message);
return true;
case kMediaRouter_OnRouteMessagesReceived_Name:
var params = reader.decodeStruct(MediaRouter_OnRouteMessagesReceived_Params);
this.onRouteMessagesReceived(params.routeId, params.messages);
return true;
case kMediaRouter_OnMediaRemoterCreated_Name:
var params = reader.decodeStruct(MediaRouter_OnMediaRemoterCreated_Params);
this.onMediaRemoterCreated(params.tabId, params.remoter,
params.remotingSource);
return true;
case kMediaRouter_GetMirroringServiceHostForTab_Name:
var params =
reader.decodeStruct(MediaRouter_GetMirroringServiceHostForTab_Params);
this.getMirroringServiceHostForTab(params.targetTabId, params.request);
return true;
case kMediaRouter_GetMirroringServiceHostForDesktop_Name:
var params =
reader.decodeStruct(MediaRouter_GetMirroringServiceHostForDesktop_Params);
this.getMirroringServiceHostForDesktop(params.initiatorTabId,
params.desktopStreamId, params.request);
return true;
case kMediaRouter_GetMirroringServiceHostForOffscreenTab_Name:
var params =
reader.decodeStruct(MediaRouter_GetMirroringServiceHostForOffscreenTab_Params);
this.getMirroringServiceHostForOffscreenTab(params.presentationUrl,
params.presentationId, params.request);
return true;
default:
return false;
}
};
MediaRouterStub.prototype.acceptWithResponder =
function(message, responder) {
case kMediaRouter_RegisterMediaRouteProvider_Name:
var params =
reader.decodeStruct(MediaRouter_RegisterMediaRouteProvider_Params);
this.registerMediaRouteProvider(params.providerId,
params.mediaRouterProvider).then(function(response) {
new MediaRouter_RegisterMediaRouteProvider_ResponseParams();
responseParams.instanceId = response.instanceId;
responseParams.config = response.config;
kMediaRouter_RegisterMediaRouteProvider_Name,
codec.align(MediaRouter_RegisterMediaRouteProvider_ResponseParams.encodedSize),
builder.encodeStruct(MediaRouter_RegisterMediaRouteProvider_ResponseParams,
responseParams);
});
return true;
case kMediaRouter_GetMediaSinkServiceStatus_Name:
var params =
reader.decodeStruct(MediaRouter_GetMediaSinkServiceStatus_Params);
this.getMediaSinkServiceStatus().then(function(response) {
new MediaRouter_GetMediaSinkServiceStatus_ResponseParams();
responseParams.status = response.status;
kMediaRouter_GetMediaSinkServiceStatus_Name,
codec.align(MediaRouter_GetMediaSinkServiceStatus_ResponseParams.encodedSize),
builder.encodeStruct(MediaRouter_GetMediaSinkServiceStatus_ResponseParams,
responseParams);
});
return true;
default:
return false;
}
};
function validateMediaRouterRequest(messageValidator) {
paramsClass = MediaRouter_RegisterMediaRouteProvider_Params;
break;
case kMediaRouter_OnSinksReceived_Name:
paramsClass = MediaRouter_OnSinksReceived_Params;
break;
case kMediaRouter_OnIssue_Name:
paramsClass = MediaRouter_OnIssue_Params;
break;
case kMediaRouter_OnRoutesUpdated_Name:
paramsClass = MediaRouter_OnRoutesUpdated_Params;
break;
case kMediaRouter_OnSinkAvailabilityUpdated_Name:
paramsClass = MediaRouter_OnSinkAvailabilityUpdated_Params;
break;
case kMediaRouter_OnPresentationConnectionStateChanged_Name:
paramsClass = MediaRouter_OnPresentationConnectionStateChanged_Params;
break;
case kMediaRouter_OnPresentationConnectionClosed_Name:
paramsClass = MediaRouter_OnPresentationConnectionClosed_Params;
break;
case kMediaRouter_OnRouteMessagesReceived_Name:
paramsClass = MediaRouter_OnRouteMessagesReceived_Params;
break;
case kMediaRouter_OnMediaRemoterCreated_Name:
paramsClass = MediaRouter_OnMediaRemoterCreated_Params;
break;
paramsClass = MediaRouter_GetMediaSinkServiceStatus_Params;
break;
case kMediaRouter_GetMirroringServiceHostForTab_Name:
paramsClass = MediaRouter_GetMirroringServiceHostForTab_Params;
break;
case kMediaRouter_GetMirroringServiceHostForDesktop_Name:
paramsClass = MediaRouter_GetMirroringServiceHostForDesktop_Params;
break;
case kMediaRouter_GetMirroringServiceHostForOffscreenTab_Name:
paramsClass = MediaRouter_GetMirroringServiceHostForOffscreenTab_Params;
break;
}
}
function validateMediaRouterResponse(messageValidator) {
paramsClass = MediaRouter_RegisterMediaRouteProvider_ResponseParams;
break;
paramsClass = MediaRouter_GetMediaSinkServiceStatus_ResponseParams;
break;
}
}
var MediaRouter = {
name: 'media_router.mojom.MediaRouter',
kVersion: 0,
ptrClass: MediaRouterPtr,
proxyClass: MediaRouterProxy,
stubClass: MediaRouterStub,
validateRequest: validateMediaRouterRequest,
validateResponse: validateMediaRouterResponse,
};
MediaRouter.SinkAvailability = {};
MediaRouter.SinkAvailability.UNAVAILABLE = 0;
MediaRouter.SinkAvailability.PER_SOURCE =
MediaRouter.SinkAvailability.UNAVAILABLE + 1;
MediaRouter.SinkAvailability.AVAILABLE = MediaRouter.SinkAvailability.PER_SOURCE
+ 1;
MediaRouter.SinkAvailability.MIN_VALUE = 0,
MediaRouter.SinkAvailability.MAX_VALUE = 2,
MediaRouter.SinkAvailability.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
return true;
}
return false;
};
MediaRouter.SinkAvailability.validate = function(enumValue) {
};
MediaRouter.PresentationConnectionState = {};
MediaRouter.PresentationConnectionState.CONNECTING = 0;
MediaRouter.PresentationConnectionState.CONNECTED =
MediaRouter.PresentationConnectionState.CONNECTING + 1;
MediaRouter.PresentationConnectionState.CLOSED =
MediaRouter.PresentationConnectionState.CONNECTED + 1;
MediaRouter.PresentationConnectionState.TERMINATED =
MediaRouter.PresentationConnectionState.CLOSED + 1;
MediaRouter.PresentationConnectionState.MIN_VALUE = 0,
MediaRouter.PresentationConnectionState.MAX_VALUE = 3,
MediaRouter.PresentationConnectionState.isKnownEnumValue = function(value) {
switch (value) {
case 0:
case 1:
case 2:
case 3:
return true;
}
return false;
};
MediaRouter.PresentationConnectionState.validate = function(enumValue) {
};
MediaRouter.PresentationConnectionCloseReason = {};
MediaRouter.PresentationConnectionCloseReason.CONNECTION_ERROR = 0;
MediaRouter.PresentationConnectionCloseReason.CLOSED =
MediaRouter.PresentationConnectionCloseReason.CONNECTION_ERROR + 1;
MediaRouter.PresentationConnectionCloseReason.WENT_AWAY =
MediaRouter.PresentationConnectionCloseReason.CLOSED + 1;
MediaRouter.PresentationConnectionCloseReason.MIN_VALUE = 0,
MediaRouter.PresentationConnectionCloseReason.MAX_VALUE = 2,
MediaRouter.PresentationConnectionCloseReason.isKnownEnumValue = function(value)
{
switch (value) {
case 0:
case 1:
case 2:
return true;
}
return false;
};
MediaRouter.PresentationConnectionCloseReason.validate = function(enumValue) {
};
MediaRouterStub.prototype.validator = validateMediaRouterRequest;
MediaRouterProxy.prototype.validator = validateMediaRouterResponse;
exports.SinkIconType = SinkIconType;
exports.RouteControllerType = RouteControllerType;
exports.RouteRequestResultCode = RouteRequestResultCode;
exports.MediaSink = MediaSink;
exports.DialMediaSink = DialMediaSink;
exports.CastMediaSink = CastMediaSink;
exports.MediaRoute = MediaRoute;
exports.Issue = Issue;
exports.RouteMessage = RouteMessage;
exports.SinkSearchCriteria = SinkSearchCriteria;
exports.MediaRouteProviderConfig = MediaRouteProviderConfig;
exports.RoutePresentationConnection = RoutePresentationConnection;
exports.MediaSinkExtraData = MediaSinkExtraData;
exports.MediaRouteProvider = MediaRouteProvider;
exports.MediaRouteProviderPtr = MediaRouteProviderPtr;
exports.MediaRouteProviderAssociatedPtr = MediaRouteProviderAssociatedPtr;
exports.MediaRouter = MediaRouter;
exports.MediaRouterPtr = MediaRouterPtr;
exports.MediaRouterAssociatedPtr = MediaRouterAssociatedPtr;
})();// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
'use strict';
if ((typeof mojo === 'undefined') || !mojo.bindingsLibraryInitialized) {

loadScript('mojo_bindings');
}
mojo.config.autoLoadMojomDeps = false;
loadScript('chrome/common/media_router/mojo/media_controller.mojom');
loadScript('chrome/common/media_router/mojo/media_router.mojom');
loadScript('chrome/common/media_router/mojo/media_status.mojom');
loadScript('components/mirroring/mojom/cast_message_channel.mojom');
loadScript('components/mirroring/mojom/mirroring_service_host.mojom');
loadScript('components/mirroring/mojom/session_observer.mojom');
loadScript('components/mirroring/mojom/session_parameters.mojom');
loadScript('extensions/common/mojo/keep_alive.mojom');
loadScript('media/mojo/interfaces/mirror_service_remoting.mojom');
loadScript('media/mojo/interfaces/remoting_common.mojom');
loadScript('mojo/public/mojom/base/time.mojom');
loadScript('mojo/public/mojom/base/unguessable_token.mojom');
loadScript('net/interfaces/ip_address.mojom');
loadScript('net/interfaces/ip_endpoint.mojom');
loadScript('url/mojom/origin.mojom');
loadScript('url/mojom/url.mojom');
// The following adapter classes preserve backward compatibility for the media
// router component extension.
// TODO(crbug.com/787128): Remove these adapters.
function assignFields(object, fields) {

if (object.hasOwnProperty(field))
object[field] = fields[field];
}
}
/**
* Adapter for mediaRouter.mojom.DialMediaSink.
* @constructor
*/
function DialMediaSinkAdapter(fields) {
this.ip_address = null;
this.model_name = null;
this.app_url = null;
assignFields(this, fields);
}
DialMediaSinkAdapter.fromNewVersion = function(other) {
return new DialMediaSinkAdapter({
'ip_address': IPAddressAdapter.fromNewVersion(other.ipAddress),
'model_name': other.modelName,
'app_url': other.appUrl,
});
};
DialMediaSinkAdapter.prototype.toNewVersion = function() {
return new mediaRouter.mojom.DialMediaSink({
'ipAddress' : this.ip_address.toNewVersion(),
'modelName' : this.model_name,
'appUrl' : this.app_url,
});
};
/**
* Adapter for mediaRouter.mojom.CastMediaSink.
* @constructor
*/
function CastMediaSinkAdapter(fields) {
this.ip_endpoint = null;
this.model_name = null;
this.capabilities = 0;
this.cast_channel_id = 0;
}
CastMediaSinkAdapter.fromNewVersion = function(other) {
return new CastMediaSinkAdapter({
'ip_endpoint': IPEndpointAdapter.fromNewVersion(other.ipEndpoint),
'model_name': other.modelName,
'capabilities': other.capabilities,
'cast_channel_id': other.castChannelId,
});
};
CastMediaSinkAdapter.prototype.toNewVersion = function() {
return new mediaRouter.mojom.CastMediaSink({
'ipEndpoint': this.ip_endpoint.toNewVersion(),
'modelName': this.model_name,
'capabilities': this.capabilities,
'castChannelId': this.cast_channel_id,
});
};
/**
* Adapter for mediaRouter.mojom.HangoutsMediaStatusExtraData.
* @constructor
*/
function HangoutsMediaStatusExtraDataAdapter(fields) {
this.local_present = false;
}
HangoutsMediaStatusExtraDataAdapter.prototype.toNewVersion = function() {
return new mediaRouter.mojom.HangoutsMediaStatusExtraData({
'localPresent': this.local_present,
});
};
/**
* Adapter for net.interfaces.IPAddress.
* @constructor
*/
function IPAddressAdapter(fields) {
this.address_bytes = null;
}
IPAddressAdapter.fromNewVersion = function(other) {
return new IPAddressAdapter({
'address_bytes': other.addressBytes,
});
};
IPAddressAdapter.prototype.toNewVersion = function() {
return new net.interfaces.IPAddress({
'addressBytes': this.address_bytes,
});
};
/**
* Adapter for net.interfaces.IPEndpoint.
* @constructor
*/
function IPEndpointAdapter(fields) {
this.address = null;
this.port = 0;
}
IPEndpointAdapter.fromNewVersion = function(other) {
return new IPEndpointAdapter({
'address': IPAddressAdapter.fromNewVersion(other.address),
'port': other.port,
});
};
IPEndpointAdapter.prototype.toNewVersion = function() {
return new net.interfaces.IPEndpoint({
'address': this.address.toNewVersion(),
'port': this.port,
});
};
/**
* Adapter for mediaRouter.mojom.MediaStatus.
* @constructor
*/
function MediaStatusAdapter(fields) {
this.title = null;
this.can_play_pause = false;
this.can_mute = false;
this.can_set_volume = false;
this.can_seek = false;
this.is_muted = false;
this.play_state = 0;
this.volume = 0;
this.duration = null;
this.current_time = null;
this.hangouts_extra_data = null;
}
MediaStatusAdapter.PlayState = mediaRouter.mojom.MediaStatus.PlayState;
MediaStatusAdapter.prototype.toNewVersion = function() {
return new mediaRouter.mojom.MediaStatus({
'title': this.title,
'canPlayPause': this.can_play_pause,
'canMute': this.can_mute,
'canSetVolume': this.can_set_volume,
'canSeek': this.can_seek,
'isMuted': this.is_muted,
'playState': this.play_state,
'volume': this.volume,
'duration': this.duration,
'currentTime': this.current_time,
'hangoutsExtraData':
this.hangouts_extra_data && this.hangouts_extra_data.toNewVersion(),
});
};
/**
* Adapter for media.mojom.RemotingSinkMetadata.
* @constructor
*/
function RemotingSinkMetadataAdapter(fields) {
this.features = null;
this.audio_capabilities = null;
this.video_capabilities = null;
this.friendly_name = null;
}
RemotingSinkMetadataAdapter.fromNewVersion = function(other) {
return new RemotingSinkMetadataAdapter({
'features': other.features,
'audio_capabilities': other.audioCapabilities,
'video_capabilities': other.videoCapabilities,
'friendly_name': other.friendlyName,
});
};
RemotingSinkMetadataAdapter.prototype.toNewVersion = function() {
return new media.mojom.RemotingSinkMetadata({
'features': this.features,
'audioCapabilities': this.audio_capabilities,
'videoCapabilities': this.video_capabilities,
'friendlyName': this.friendly_name,
});
};
/**
* Adapter for mediaRouter.mojom.MediaSink.
* @constructor
*/
function MediaSinkAdapter(fields) {
this.sink_id = null;
this.name = null;
this.description = null;
this.domain = null;
this.icon_type = 0;
this.extra_data = null;
}
MediaSinkAdapter.fromNewVersion = function(other) {
return new MediaSinkAdapter({
'sink_id': other.sinkId,
'name': other.name,
'description': other.description,
'domain': other.domain,
'icon_type': other.iconType,
'extra_data': other.extraData &&
MediaSinkExtraDataAdapter.fromNewVersion(other.extraData),
});
};
MediaSinkAdapter.prototype.toNewVersion = function() {
return new mediaRouter.mojom.MediaSink({
'sinkId': this.sink_id,
'name': this.name,
'description': this.description,
'domain': this.domain,
'iconType': this.icon_type,
'extraData': this.extra_data && this.extra_data.toNewVersion(),
});
};
/**
* Adapter for mediaRouter.mojom.MediaSinkExtraData.
* @constructor
*/
function MediaSinkExtraDataAdapter(value) {
this.$data = null;
this.$tag = undefined;
if (value == undefined) {
return;
}
var keys = Object.keys(value);

if (keys.length == 0) {
return;
}
if (keys.length > 1) {
throw new TypeError('You may set only one member on a union.');
}
var fields = [
'dial_media_sink',
'cast_media_sink',
];
if (fields.indexOf(keys[0]) < 0) {
throw new ReferenceError(keys[0] +
' is not a MediaSinkExtraDataAdapter member.');
}
this[keys[0]] = value[keys[0]];
}
MediaSinkExtraDataAdapter.Tags = {
dial_media_sink: 0,
cast_media_sink: 1,
};
Object.defineProperty(MediaSinkExtraDataAdapter.prototype, 'dial_media_sink', {
get: function() {
if (this.$tag != MediaSinkExtraDataAdapter.Tags.dial_media_sink) {
'MediaSinkExtraDataAdapter.dial_media_sink is not currently set.');
}
return this.$data;
},
this.$tag = MediaSinkExtraDataAdapter.Tags.dial_media_sink;
this.$data = value;
}
});
Object.defineProperty(MediaSinkExtraDataAdapter.prototype, 'cast_media_sink', {
get: function() {
if (this.$tag != MediaSinkExtraDataAdapter.Tags.cast_media_sink) {
'MediaSinkExtraDataAdapter.cast_media_sink is not currently set.');
}
return this.$data;
},
this.$tag = MediaSinkExtraDataAdapter.Tags.cast_media_sink;
this.$data = value;
}
});
MediaSinkExtraDataAdapter.fromNewVersion = function(other) {
if (other.$tag == mediaRouter.mojom.MediaSinkExtraData.Tags.dialMediaSink) {
return new MediaSinkExtraDataAdapter({
'dial_media_sink':
DialMediaSinkAdapter.fromNewVersion(other.dialMediaSink),
});
} else {
return new MediaSinkExtraDataAdapter({
'cast_media_sink':
CastMediaSinkAdapter.fromNewVersion(other.castMediaSink),
});
}
};
MediaSinkExtraDataAdapter.prototype.toNewVersion = function() {
if (this.$tag == MediaSinkExtraDataAdapter.Tags.dial_media_sink) {
return new mediaRouter.mojom.MediaSinkExtraData({
'dialMediaSink': this.dial_media_sink.toNewVersion(),
});
} else {
return new mediaRouter.mojom.MediaSinkExtraData({
'castMediaSink': this.cast_media_sink.toNewVersion(),
});
}
};
/**
* Adapter for media.mojom.MirrorServiceRemoterPtr.
* @constructor
*/
function MirrorServiceRemoterPtrAdapter(handleOrPtrInfo) {
this.ptr = new mojo.InterfacePtrController(MirrorServiceRemoterAdapter,
handleOrPtrInfo);
}
MirrorServiceRemoterPtrAdapter.prototype =
Object.create(media.mojom.MirrorServiceRemoterPtr.prototype);
MirrorServiceRemoterPtrAdapter.prototype.constructor =
MirrorServiceRemoterPtrAdapter;
MirrorServiceRemoterPtrAdapter.prototype.startDataStreams = function() {
return MirrorServiceRemoterProxy.prototype.startDataStreams
.apply(this.ptr.getProxy(), arguments).then(function(response) {
return Promise.resolve({
'audio_stream_id': response.audioStreamId,
'video_stream_id': response.videoStreamId,
});
});
};
/**
* Adapter for media.mojom.MirrorServiceRemoter.stubclass.
* @constructor
*/
function MirrorServiceRemoterStubAdapter(delegate) {
}
MirrorServiceRemoterStubAdapter.prototype = Object.create(
media.mojom.MirrorServiceRemoter.stubClass.prototype);
MirrorServiceRemoterStubAdapter.prototype.constructor =
MirrorServiceRemoterStubAdapter;
MirrorServiceRemoterStubAdapter.prototype.startDataStreams =
function(hasAudio, hasVideo) {
return this.delegate_ && this.delegate_.startDataStreams &&
this.delegate_.startDataStreams(hasAudio, hasVideo).then(
function(response) {
return {
'audioStreamId': response.audio_stream_id,
'videoStreamId': response.video_stream_id,
};
});
};
/**
* Adapter for media.mojom.MirrorServiceRemoter.
*/
var MirrorServiceRemoterAdapter = {
name: 'media.mojom.MirrorServiceRemoter',
kVersion: 0,
ptrClass: MirrorServiceRemoterPtrAdapter,
proxyClass: media.mojom.MirrorServiceRemoter.proxyClass,
stubClass: MirrorServiceRemoterStubAdapter,
validateRequest: media.mojom.MirrorServiceRemoter.validateRequest,
validateResponse: media.mojom.MirrorServiceRemoter.validateResponse,
};
/**
* Adapter for media.mojom.MirrorServiceRemotingSourcePtr.
* @constructor
*/
function MirrorServiceRemotingSourcePtrAdapter(handleOrPtrInfo) {
this.ptr = new mojo.InterfacePtrController(MirrorServiceRemotingSourceAdapter,
handleOrPtrInfo);
}
MirrorServiceRemotingSourcePtrAdapter.prototype =
Object.create(media.mojom.MirrorServiceRemotingSourcePtr.prototype);
MirrorServiceRemotingSourcePtrAdapter.prototype.constructor =
MirrorServiceRemotingSourcePtrAdapter;
MirrorServiceRemotingSourcePtrAdapter.prototype.onSinkAvailable =
function(metadata) {
return this.ptr.getProxy().onSinkAvailable(metadata.toNewVersion());
};
/**
* Adapter for media.mojom.MirrorServiceRemotingSource.
*/
var MirrorServiceRemotingSourceAdapter = {
name: 'media.mojom.MirrorServiceRemotingSource',
kVersion: 0,
ptrClass: MirrorServiceRemotingSourcePtrAdapter,
proxyClass: media.mojom.MirrorServiceRemotingSource.proxyClass,
stubClass: null,
validateRequest: media.mojom.MirrorServiceRemotingSource.validateRequest,
validateResponse: null,
};
/**
* Adapter for mediaRouter.mojom.MediaStatusObserver.
* @constructor
*/
function MediaStatusObserverPtrAdapter(handleOrPtrInfo) {
this.ptr = new mojo.InterfacePtrController(MediaStatusObserverAdapter,
handleOrPtrInfo);
}
MediaStatusObserverPtrAdapter.prototype =
Object.create(mediaRouter.mojom.MediaStatusObserverPtr.prototype);
MediaStatusObserverPtrAdapter.prototype.constructor =
MediaStatusObserverPtrAdapter;
MediaStatusObserverPtrAdapter.prototype.onMediaStatusUpdated =
function(status) {
return this.ptr.getProxy().onMediaStatusUpdated(status.toNewVersion());
};
/**
* Adapter for mediaRouter.mojom.MediaStatusObserver.
*/
var MediaStatusObserverAdapter = {
name: 'mediaRouter.mojom.MediaStatusObserver',
kVersion: 0,
ptrClass: MediaStatusObserverPtrAdapter,
proxyClass: mediaRouter.mojom.MediaStatusObserver.proxyClass,
stubClass: null,
validateRequest: mediaRouter.mojom.MediaStatusObserver.validateRequest,
validateResponse: null,
};
/**
* Converts a media sink to a MediaSink Mojo object.
* @param {!MediaSink} sink A media sink.
* @return {!mediaRouter.mojom.MediaSink} A Mojo MediaSink object.
*/
function sinkToMojo_(sink) {
return new mediaRouter.mojom.MediaSink({
'name': sink.friendlyName,
'description': sink.description,
'domain': sink.domain,
'sinkId': sink.id,
'iconType': sinkIconTypeToMojo(sink.iconType),
'providerId': mediaRouter.mojom.MediaRouteProvider.Id.EXTENSION,
});
}
/**
* Converts a media sink's icon type to a MediaSink.IconType Mojo object.
* @param {!MediaSink.IconType} type A media sink's icon type.
* @return {!mediaRouter.mojom.MediaSink.IconType} A Mojo MediaSink.IconType
* object.
*/
function sinkIconTypeToMojo(type) {
switch (type) {
case 'cast':
return mediaRouter.mojom.SinkIconType.CAST;
case 'cast_audio_group':
return mediaRouter.mojom.SinkIconType.CAST_AUDIO_GROUP;
case 'cast_audio':
return mediaRouter.mojom.SinkIconType.CAST_AUDIO;
case 'meeting':
return mediaRouter.mojom.SinkIconType.MEETING;
case 'hangout':
return mediaRouter.mojom.SinkIconType.HANGOUT;
case 'education':
return mediaRouter.mojom.SinkIconType.EDUCATION;
case 'generic':
return mediaRouter.mojom.SinkIconType.GENERIC;
default:
console.error('Unknown sink icon type : ' + type);
return mediaRouter.mojom.SinkIconType.GENERIC;
}
}
/**
* Returns a Mojo MediaRoute object given a MediaRoute and a
* media sink name.
* @param {!MediaRoute} route
* @return {!mediaRouter.mojom.MediaRoute}
*/
function routeToMojo_(route) {
return new mediaRouter.mojom.MediaRoute({
'mediaRouteId': route.id,
'mediaSource': route.mediaSource,
'mediaSinkId': route.sinkId,
'description': route.description,
'iconUrl': route.iconUrl,
'isLocal': route.isLocal,
'forDisplay': route.forDisplay,
'isIncognito': route.offTheRecord,
'isLocalPresentation': route.isOffscreenPresentation,
'controllerType': route.controllerType,
// Begin newly added properties, followed by the milestone they were
// added. The guard should be safe to remove N+2 milestones later.
'presentationId': route.presentationId || '' // M64
});
}
/**
* Converts a route message to a RouteMessage Mojo object.
* @param {!RouteMessage} message
* @return {!mediaRouter.mojom.RouteMessage} A Mojo RouteMessage object.
*/
function messageToMojo_(message) {
if ("string" == typeof message.message) {
return new mediaRouter.mojom.RouteMessage({
'type': mediaRouter.mojom.RouteMessage.Type.TEXT,
'message': message.message,
});
} else {
return new mediaRouter.mojom.RouteMessage({
'type': mediaRouter.mojom.RouteMessage.Type.BINARY,
'data': message.message,
});
}
}
/**
* Converts presentation connection state to Mojo enum value.
* @param {!string} state
* @return {!mediaRouter.mojom.MediaRouter.PresentationConnectionState}
*/
function presentationConnectionStateToMojo_(state) {
var PresentationConnectionState =
mediaRouter.mojom.MediaRouter.PresentationConnectionState;
switch (state) {
case 'connecting':
return PresentationConnectionState.CONNECTING;
case 'connected':
return PresentationConnectionState.CONNECTED;
case 'closed':
return PresentationConnectionState.CLOSED;
case 'terminated':
return PresentationConnectionState.TERMINATED;
default:
console.error('Unknown presentation connection state: ' + state);
return PresentationConnectionState.TERMINATED;
}
}
/**
* Converts presentation connection close reason to Mojo enum value.
* @param {!string} reason
* @return {!mediaRouter.mojom.MediaRouter.PresentationConnectionCloseReason}
*/
function presentationConnectionCloseReasonToMojo_(reason) {
var PresentationConnectionCloseReason =
mediaRouter.mojom.MediaRouter.PresentationConnectionCloseReason;
switch (reason) {
case 'error':
return PresentationConnectionCloseReason.CONNECTION_ERROR;
case 'closed':
return PresentationConnectionCloseReason.CLOSED;
case 'went_away':
return PresentationConnectionCloseReason.WENT_AWAY;
default:
console.error('Unknown presentation connection close reason : ' +
reason);
return PresentationConnectionCloseReason.CONNECTION_ERROR;
}
}
/**
* Converts string to Mojo origin.
* @param {string|!url.mojom.Origin} origin
* @return {!url.mojom.Origin}
*/
function stringToMojoOrigin_(origin) {
if (origin instanceof url.mojom.Origin) {
return origin;
}
var originUrl = new URL(origin);
var mojoOrigin = {};
mojoOrigin.scheme = originUrl.protocol.replace(':', '');
mojoOrigin.host = originUrl.hostname;
var port = originUrl.port ? Number.parseInt(originUrl.port) : 0;
switch (mojoOrigin.scheme) {
case 'http':
mojoOrigin.port = port || 80;
break;
case 'https':
mojoOrigin.port = port || 443;
break;
default:
throw new Error('Scheme must be http or https');
}
mojoOrigin.suborigin = '';
return new url.mojom.Origin(mojoOrigin);
}
/**
* Parses the given route request Error object and converts it to the
* corresponding result code.
* @param {!Error} error
* @return {!mediaRouter.mojom.RouteRequestResultCode}
*/
function getRouteRequestResultCode_(error) {
return error.errorCode ? error.errorCode :
mediaRouter.mojom.RouteRequestResultCode.UNKNOWN_ERROR;
}
/**
* Creates and returns a successful route response from given route.
* @param {!MediaRoute} route
* @return {!Object}
*/
function toSuccessRouteResponse_(route) {
return {
route: routeToMojo_(route),
resultCode: mediaRouter.mojom.RouteRequestResultCode.OK
};
}
/**
* Creates and returns a error route response from given Error object.
* @param {!Error} error
* @return {!Object}
*/
function toErrorRouteResponse_(error) {
return {
errorText: error.message,
resultCode: getRouteRequestResultCode_(error)
};
}
/**
* Creates a new MediaRouter.
* Converts a route struct to its Mojo form.
* @param {!mediaRouter.mojom.MediaRouterPtr} service
* @constructor
*/
function MediaRouter(service) {
/**
* The Mojo service proxy. Allows extension code to call methods that reside
* in the browser.
* @type {!mediaRouter.mojom.MediaRouterPtr}
*/
this.service_ = service;
/**
* The provider manager service delegate. Its methods are called by the
* browser-resident Mojo service.
* @type {!MediaRouter}
*/
this.mrpm_ = new MediaRouteProvider(this);
/**
* Handle to a KeepAlive service object, which prevents the extension from
* being suspended as long as it remains in scope.
* @type {boolean}
*/
this.keepAlive_ = null;
/**
* The bindings to bind the service delegate to the Mojo interface.
* Object must remain in scope for the lifetime of the connection to
* prevent the connection from closing automatically.
* @type {!mojo.Binding}
*/
this.mediaRouteProviderBinding_ = new mojo.Binding(
mediaRouter.mojom.MediaRouteProvider, this.mrpm_);
}
/**
* Returns definitions of Mojo core and generated Mojom classes that can be
* used directly by the component.
* @return {!Object}
* TODO(imcheng): We should export these along with MediaRouter. This requires
* us to modify the component to handle multiple exports. When that logic is
* baked in for a couple of milestones, we should be able to remove this
* method.
* TODO(imcheng): We should stop exporting mojo bindings classes that the
* Media Router extension doesn't directly use, such as
* mojo.AssociatedInterfacePtrInfo, mojo.InterfacePtrController and
* mojo.interfaceControl.
*/
MediaRouter.prototype.getMojoExports = function() {
return {
AssociatedInterfacePtrInfo: mojo.AssociatedInterfacePtrInfo,
Binding: mojo.Binding,
DialMediaSink: DialMediaSinkAdapter,
CastMediaSink: CastMediaSinkAdapter,
HangoutsMediaRouteController:
mediaRouter.mojom.HangoutsMediaRouteController,
HangoutsMediaStatusExtraData: HangoutsMediaStatusExtraDataAdapter,
IPAddress: IPAddressAdapter,
IPEndpoint: IPEndpointAdapter,
InterfacePtrController: mojo.InterfacePtrController,
InterfacePtrInfo: mojo.InterfacePtrInfo,
InterfaceRequest: mojo.InterfaceRequest,
MediaController: mediaRouter.mojom.MediaController,
MediaStatus: MediaStatusAdapter,
MediaStatusObserverPtr: mediaRouter.mojom.MediaStatusObserverPtr,
MirroringCastMessage: mirroring.mojom.CastMessage,
MirroringCastMessageChannel: mirroring.mojom.CastMessageChannel,
MirroringCastMessageChannelPtr: mirroring.mojom.CastMessageChannelPtr,
MirroringServiceHostPtr: mirroring.mojom.MirroringServiceHostPtr,
MirroringSessionError: mirroring.mojom.SessionError,
MirroringSessionObserver: mirroring.mojom.SessionObserver,
MirroringSessionObserverPtr: mirroring.mojom.SessionObserverPtr,
MirroringSessionParameters: mirroring.mojom.SessionParameters,
MirroringSessionType: mirroring.mojom.SessionType,
MirroringRemotingNamespace: mirroring.mojom.kRemotingNamespace,
MirroringWebRtcNamespace: mirroring.mojom.kWebRtcNamespace,
MirrorServiceRemoter: MirrorServiceRemoterAdapter,
MirrorServiceRemoterPtr: MirrorServiceRemoterPtrAdapter,
MirrorServiceRemotingSourcePtr: MirrorServiceRemotingSourcePtrAdapter,
RemotingStopReason: media.mojom.RemotingStopReason,
RemotingStartFailReason: media.mojom.RemotingStartFailReason,
RemotingSinkFeature: media.mojom.RemotingSinkFeature,
RemotingSinkAudioCapability:
media.mojom.RemotingSinkAudioCapability,
RemotingSinkVideoCapability:
media.mojom.RemotingSinkVideoCapability,
RemotingSinkMetadata: RemotingSinkMetadataAdapter,
RouteControllerType: mediaRouter.mojom.RouteControllerType,
Origin: url.mojom.Origin,
Sink: MediaSinkAdapter,
SinkExtraData: MediaSinkExtraDataAdapter,
TimeDelta: mojoBase.mojom.TimeDelta,
Url: url.mojom.Url,
interfaceControl: mojo.interfaceControl,
makeRequest: mojo.makeRequest,
};
};
/**
* Registers the Media Router Provider Manager with the Media Router.
* @return {!Promise<Object>} Instance ID and config for the Media Router.
*/
MediaRouter.prototype.start = function() {
return this.service_.registerMediaRouteProvider(
mediaRouter.mojom.MediaRouteProvider.Id.EXTENSION,
this.mediaRouteProviderBinding_.createInterfacePtrAndBind()).then(
function(response) {
return {
'instance_id': response.instanceId,
'config': {
'enable_dial_discovery': response.config.enableDialDiscovery,
'enable_cast_discovery': response.config.en

Error handling in media route provider

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Error handling in media route provider

Hochgeladen von

Copyright:

Verfügbare Formate

idationError.

MediaRouteProvider_CreateRoute_Params.encodedSize = codec.kStructHeaderSize + 48;

MediaRouteProvider_CreateRoute_Params.encode = function(encoder, val) {

MediaRouteProvider_CreateRoute_ResponseParams.encode = function(encoder, val) {

MediaRouteProvider_JoinRoute_Params.validate = function(messageValidator, offset)

MediaRouteProvider_JoinRoute_Params.encodedSize = codec.kStructHeaderSize + 40;

MediaRouteProvider_JoinRoute_Params.encode = function(encoder, val) {

MediaRouteProvider_JoinRoute_ResponseParams.encode = function(encoder, val) {

MediaRouteProvider_ConnectRouteByRouteId_Params.encode = function(encoder, val) {

MediaRouteProvider_TerminateRoute_Params.encode = function(encoder, val) {

MediaRouteProvider_TerminateRoute_ResponseParams.encode = function(encoder, val)

MediaRouteProvider_SendRouteMessage_Params.encode = function(encoder, val) {

MediaRouteProvider_SendRouteBinaryMessage_Params.encode = function(encoder, val)

MediaRouteProvider_StopObservingMediaSinks_Params.encode = function(encoder, val)

MediaRouteProvider_DetachRoute_Params.encode = function(encoder, val) {

MediaRouteProvider_EnableMdnsDiscovery_Params.encode = function(encoder, val) {

MediaRouteProvider_UpdateMediaSinks_Params.encode = function(encoder, val) {

MediaRouteProvider_SearchSinks_Params.encodedSize = codec.kStructHeaderSize + 24;

MediaRouteProvider_SearchSinks_Params.encode = function(encoder, val) {

MediaRouteProvider_SearchSinks_ResponseParams.encode = function(encoder, val) {

MediaRouteProvider_ProvideSinks_Params.encode = function(encoder, val) {

MediaRouter_OnSinksReceived_Params.validate = function(messageValidator, offset)

MediaRouter_OnSinksReceived_Params.encodedSize = codec.kStructHeaderSize + 32;

MediaRouter_OnSinksReceived_Params.encode = function(encoder, val) {

MediaRouter_OnIssue_Params.validate = function(messageValidator, offset) {

MediaRouter_OnIssue_Params.encode = function(encoder, val) {

MediaRouter_OnRoutesUpdated_Params.validate = function(messageValidator, offset)

MediaRouter_OnRoutesUpdated_Params.encodedSize = codec.kStructHeaderSize + 32;

MediaRouter_OnRoutesUpdated_Params.encode = function(encoder, val) {

MediaRouter_OnSinkAvailabilityUpdated_Params.encode = function(encoder, val) {

MediaRouter_OnPresentationConnectionClosed_Params.encode = function(encoder, val)

MediaRouter_OnRouteMessagesReceived_Params.encode = function(encoder, val) {

MediaRouter_OnMediaRemoterCreated_Params.encode = function(encoder, val) {

MediaRouter_GetMediaSinkServiceStatus_Params.encode = function(encoder, val) {

MediaRouter_GetMirroringServiceHostForTab_Params.encode = function(encoder, val)

var keys = Object.keys(value);

MediaSinkExtraData.encode = function(encoder, val) {

var result = new MediaSinkExtraData();

MediaSinkExtraData.validate = function(messageValidator, offset) {

var tag = messageValidator.decodeUnionTag(offset);

MediaRouteProviderProxy.prototype.createRoute = function(mediaSource, sinkId,

MediaRouteProviderProxy.prototype.searchSinks = function(sinkId, mediaSource,

MediaRouteProviderProxy.prototype.provideSinks = function(providerName, sinks) {

MediaRouterProxy.prototype.onSinksReceived = function(providerId, mediaSource,

MediaRouterProxy.prototype.onRoutesUpdated = function(providerId, routes,

MediaRouterProxy.prototype.onRouteMessagesReceived = function(routeId, messages)

MediaRouterProxy.prototype.onMediaRemoterCreated = function(tabId, remoter,

if ((typeof mojo === 'undefined') || !mojo.bindingsLibraryInitialized) {

function assignFields(object, fields) {

var keys = Object.keys(value);

Das könnte Ihnen auch gefallen