src/chrome/renderer/extensions/cast_streaming_native_handler.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/renderer/extensions/cast_streaming_native_handler.h"
   6
   7 #include <functional>
   8 #include <iterator>
   9
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "chrome/common/extensions/api/cast_streaming_rtp_stream.h"
  14 #include "chrome/common/extensions/api/cast_streaming_udp_transport.h"
  15 #include "chrome/renderer/media/cast_rtp_stream.h"
  16 #include "chrome/renderer/media/cast_session.h"
  17 #include "chrome/renderer/media/cast_udp_transport.h"
  18 #include "content/public/renderer/v8_value_converter.h"
  19 #include "extensions/renderer/script_context.h"
  20 #include "net/base/host_port_pair.h"
  21 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
  22 #include "third_party/WebKit/public/web/WebDOMMediaStreamTrack.h"
  23
  24 using content::V8ValueConverter;
  25
  26 // Extension types.
  27 using extensions::api::cast_streaming_rtp_stream::CodecSpecificParams;
  28 using extensions::api::cast_streaming_rtp_stream::RtpParams;
  29 using extensions::api::cast_streaming_rtp_stream::RtpPayloadParams;
  30 using extensions::api::cast_streaming_udp_transport::IPEndPoint;
  31
  32 namespace extensions {
  33
  34 namespace {
  35 const char kRtpStreamNotFound[] = "The RTP stream cannot be found";
  36 const char kUdpTransportNotFound[] = "The UDP transport cannot be found";
  37 const char kInvalidDestination[] = "Invalid destination";
  38 const char kInvalidRtpParams[] = "Invalid value for RTP params";
  39 const char kInvalidAesKey[] = "Invalid value for AES key";
  40 const char kInvalidAesIvMask[] = "Invalid value for AES IV mask";
  41 const char kInvalidStreamArgs[] = "Invalid stream arguments";
  42 const char kUnableToConvertArgs[] = "Unable to convert arguments";
  43 const char kUnableToConvertParams[] = "Unable to convert params";
  44
  45 // These helper methods are used to convert between Extension API
  46 // types and Cast types.
  47 void ToCastCodecSpecificParams(const CodecSpecificParams& ext_params,
  48                                CastCodecSpecificParams* cast_params) {
  49   cast_params->key = ext_params.key;
  50   cast_params->value = ext_params.value;
  51 }
  52
  53 void FromCastCodecSpecificParams(const CastCodecSpecificParams& cast_params,
  54                                  CodecSpecificParams* ext_params) {
  55   ext_params->key = cast_params.key;
  56   ext_params->value = cast_params.value;
  57 }
  58
  59 namespace {
  60 bool HexDecode(const std::string& input, std::string* output) {
  61   std::vector<uint8> bytes;
  62   if (!base::HexStringToBytes(input, &bytes))
  63     return false;
  64   output->assign(reinterpret_cast<const char*>(&bytes[0]), bytes.size());
  65   return true;
  66 }
  67 }  // namespace
  68
  69 bool ToCastRtpPayloadParamsOrThrow(v8::Isolate* isolate,
  70                                    const RtpPayloadParams& ext_params,
  71                                    CastRtpPayloadParams* cast_params) {
  72   cast_params->payload_type = ext_params.payload_type;
  73   cast_params->max_latency_ms = ext_params.max_latency;
  74   cast_params->min_latency_ms =
  75       ext_params.min_latency ? *ext_params.min_latency : ext_params.max_latency;
  76   cast_params->codec_name = ext_params.codec_name;
  77   cast_params->ssrc = ext_params.ssrc;
  78   cast_params->feedback_ssrc = ext_params.feedback_ssrc;
  79   cast_params->clock_rate = ext_params.clock_rate ? *ext_params.clock_rate : 0;
  80   cast_params->min_bitrate =
  81       ext_params.min_bitrate ? *ext_params.min_bitrate : 0;
  82   cast_params->max_bitrate =
  83       ext_params.max_bitrate ? *ext_params.max_bitrate : 0;
  84   cast_params->channels = ext_params.channels ? *ext_params.channels : 0;
  85   cast_params->max_frame_rate =
  86       ext_params.max_frame_rate ? *ext_params.max_frame_rate : 0.0;
  87   cast_params->width = ext_params.width ? *ext_params.width : 0;
  88   cast_params->height = ext_params.height ? *ext_params.height : 0;
  89   if (ext_params.aes_key &&
  90       !HexDecode(*ext_params.aes_key, &cast_params->aes_key)) {
  91     isolate->ThrowException(v8::Exception::Error(
  92         v8::String::NewFromUtf8(isolate, kInvalidAesKey)));
  93     return false;
  94   }
  95   if (ext_params.aes_iv_mask &&
  96       !HexDecode(*ext_params.aes_iv_mask, &cast_params->aes_iv_mask)) {
  97     isolate->ThrowException(v8::Exception::Error(
  98         v8::String::NewFromUtf8(isolate, kInvalidAesIvMask)));
  99     return false;
 100   }
 101   for (size_t i = 0; i < ext_params.codec_specific_params.size(); ++i) {
 102     CastCodecSpecificParams cast_codec_params;
 103     ToCastCodecSpecificParams(*ext_params.codec_specific_params[i],
 104                               &cast_codec_params);
 105     cast_params->codec_specific_params.push_back(cast_codec_params);
 106   }
 107   return true;
 108 }
 109
 110 void FromCastRtpPayloadParams(const CastRtpPayloadParams& cast_params,
 111                               RtpPayloadParams* ext_params) {
 112   ext_params->payload_type = cast_params.payload_type;
 113   ext_params->max_latency = cast_params.max_latency_ms;
 114   ext_params->codec_name = cast_params.codec_name;
 115   ext_params->ssrc = cast_params.ssrc;
 116   ext_params->feedback_ssrc = cast_params.feedback_ssrc;
 117   if (cast_params.clock_rate)
 118     ext_params->clock_rate.reset(new int(cast_params.clock_rate));
 119   if (cast_params.min_bitrate)
 120     ext_params->min_bitrate.reset(new int(cast_params.min_bitrate));
 121   if (cast_params.max_bitrate)
 122     ext_params->max_bitrate.reset(new int(cast_params.max_bitrate));
 123   if (cast_params.channels)
 124     ext_params->channels.reset(new int(cast_params.channels));
 125   if (cast_params.max_frame_rate > 0.0)
 126     ext_params->max_frame_rate.reset(new double(cast_params.max_frame_rate));
 127   if (cast_params.width)
 128     ext_params->width.reset(new int(cast_params.width));
 129   if (cast_params.height)
 130     ext_params->height.reset(new int(cast_params.height));
 131   for (size_t i = 0; i < cast_params.codec_specific_params.size(); ++i) {
 132     linked_ptr<CodecSpecificParams> ext_codec_params(
 133         new CodecSpecificParams());
 134     FromCastCodecSpecificParams(cast_params.codec_specific_params[i],
 135                                 ext_codec_params.get());
 136     ext_params->codec_specific_params.push_back(ext_codec_params);
 137   }
 138 }
 139
 140 void FromCastRtpParams(const CastRtpParams& cast_params,
 141                        RtpParams* ext_params) {
 142   std::copy(cast_params.rtcp_features.begin(),
 143             cast_params.rtcp_features.end(),
 144             std::back_inserter(ext_params->rtcp_features));
 145   FromCastRtpPayloadParams(cast_params.payload, &ext_params->payload);
 146 }
 147
 148 bool ToCastRtpParamsOrThrow(v8::Isolate* isolate,
 149                             const RtpParams& ext_params,
 150                             CastRtpParams* cast_params) {
 151   std::copy(ext_params.rtcp_features.begin(),
 152             ext_params.rtcp_features.end(),
 153             std::back_inserter(cast_params->rtcp_features));
 154   if (!ToCastRtpPayloadParamsOrThrow(isolate,
 155                                      ext_params.payload,
 156                                      &cast_params->payload)) {
 157     return false;
 158   }
 159   return true;
 160 }
 161
 162 }  // namespace
 163
 164 CastStreamingNativeHandler::CastStreamingNativeHandler(ScriptContext* context)
 165     : ObjectBackedNativeHandler(context),
 166       last_transport_id_(1),
 167       weak_factory_(this) {
 168   RouteFunction("CreateSession",
 169       base::Bind(&CastStreamingNativeHandler::CreateCastSession,
 170                  base::Unretained(this)));
 171   RouteFunction("DestroyCastRtpStream",
 172       base::Bind(&CastStreamingNativeHandler::DestroyCastRtpStream,
 173                  base::Unretained(this)));
 174   RouteFunction("GetSupportedParamsCastRtpStream",
 175       base::Bind(&CastStreamingNativeHandler::GetSupportedParamsCastRtpStream,
 176                  base::Unretained(this)));
 177   RouteFunction("StartCastRtpStream",
 178       base::Bind(&CastStreamingNativeHandler::StartCastRtpStream,
 179                  base::Unretained(this)));
 180   RouteFunction("StopCastRtpStream",
 181       base::Bind(&CastStreamingNativeHandler::StopCastRtpStream,
 182                  base::Unretained(this)));
 183   RouteFunction("DestroyCastUdpTransport",
 184       base::Bind(&CastStreamingNativeHandler::DestroyCastUdpTransport,
 185                  base::Unretained(this)));
 186   RouteFunction("SetDestinationCastUdpTransport",
 187       base::Bind(&CastStreamingNativeHandler::SetDestinationCastUdpTransport,
 188                  base::Unretained(this)));
 189   RouteFunction("SetOptionsCastUdpTransport",
 190       base::Bind(&CastStreamingNativeHandler::SetOptionsCastUdpTransport,
 191                  base::Unretained(this)));
 192   RouteFunction("ToggleLogging",
 193                 base::Bind(&CastStreamingNativeHandler::ToggleLogging,
 194                            base::Unretained(this)));
 195   RouteFunction("GetRawEvents",
 196                 base::Bind(&CastStreamingNativeHandler::GetRawEvents,
 197                            base::Unretained(this)));
 198   RouteFunction("GetStats",
 199                 base::Bind(&CastStreamingNativeHandler::GetStats,
 200                            base::Unretained(this)));
 201 }
 202
 203 CastStreamingNativeHandler::~CastStreamingNativeHandler() {
 204 }
 205
 206 void CastStreamingNativeHandler::CreateCastSession(
 207     const v8::FunctionCallbackInfo<v8::Value>& args) {
 208   CHECK_EQ(3, args.Length());
 209   CHECK(args[2]->IsFunction());
 210
 211   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
 212   if ((args[0]->IsNull() || args[0]->IsUndefined()) &&
 213       (args[1]->IsNull() || args[1]->IsUndefined())) {
 214     isolate->ThrowException(v8::Exception::Error(
 215         v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
 216     return;
 217   }
 218
 219   scoped_refptr<CastSession> session(new CastSession());
 220   scoped_ptr<CastRtpStream> stream1, stream2;
 221   if (!args[0]->IsNull() && !args[0]->IsUndefined()) {
 222     CHECK(args[0]->IsObject());
 223     blink::WebDOMMediaStreamTrack track =
 224         blink::WebDOMMediaStreamTrack::fromV8Value(args[0]);
 225     if (track.isNull()) {
 226       isolate->ThrowException(v8::Exception::Error(
 227           v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
 228       return;
 229     }
 230     stream1.reset(new CastRtpStream(track.component(), session));
 231   }
 232   if (!args[1]->IsNull() && !args[1]->IsUndefined()) {
 233     CHECK(args[1]->IsObject());
 234     blink::WebDOMMediaStreamTrack track =
 235         blink::WebDOMMediaStreamTrack::fromV8Value(args[1]);
 236     if (track.isNull()) {
 237       isolate->ThrowException(v8::Exception::Error(
 238           v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
 239       return;
 240     }
 241     stream2.reset(new CastRtpStream(track.component(), session));
 242   }
 243   scoped_ptr<CastUdpTransport> udp_transport(
 244       new CastUdpTransport(session));
 245
 246   // TODO(imcheng): Use a weak reference to ensure we don't call into an
 247   // invalid context when the callback is invoked.
 248   create_callback_.reset(args[2].As<v8::Function>());
 249
 250   base::MessageLoop::current()->PostTask(
 251       FROM_HERE,
 252       base::Bind(
 253           &CastStreamingNativeHandler::CallCreateCallback,
 254           weak_factory_.GetWeakPtr(),
 255           base::Passed(&stream1),
 256           base::Passed(&stream2),
 257           base::Passed(&udp_transport)));
 258 }
 259
 260 void CastStreamingNativeHandler::CallCreateCallback(
 261     scoped_ptr<CastRtpStream> stream1,
 262     scoped_ptr<CastRtpStream> stream2,
 263     scoped_ptr<CastUdpTransport> udp_transport) {
 264   v8::Isolate* isolate = context()->isolate();
 265   v8::HandleScope handle_scope(isolate);
 266   v8::Context::Scope context_scope(context()->v8_context());
 267
 268   v8::Handle<v8::Value> callback_args[3];
 269   callback_args[0] = v8::Null(isolate);
 270   callback_args[1] = v8::Null(isolate);
 271
 272   if (stream1) {
 273     const int stream1_id = last_transport_id_++;
 274     callback_args[0] = v8::Integer::New(isolate, stream1_id);
 275     rtp_stream_map_[stream1_id] =
 276         linked_ptr<CastRtpStream>(stream1.release());
 277   }
 278   if (stream2) {
 279     const int stream2_id = last_transport_id_++;
 280     callback_args[1] = v8::Integer::New(isolate, stream2_id);
 281     rtp_stream_map_[stream2_id] =
 282         linked_ptr<CastRtpStream>(stream2.release());
 283   }
 284   const int udp_id = last_transport_id_++;
 285   udp_transport_map_[udp_id] =
 286       linked_ptr<CastUdpTransport>(udp_transport.release());
 287   callback_args[2] = v8::Integer::New(isolate, udp_id);
 288   context()->CallFunction(create_callback_.NewHandle(isolate),
 289                           3, callback_args);
 290   create_callback_.reset();
 291 }
 292
 293 void CastStreamingNativeHandler::CallStartCallback(int stream_id) {
 294   v8::Isolate* isolate = context()->isolate();
 295   v8::HandleScope handle_scope(isolate);
 296   v8::Context::Scope context_scope(context()->v8_context());
 297   v8::Handle<v8::Array> event_args = v8::Array::New(isolate, 1);
 298   event_args->Set(0, v8::Integer::New(isolate, stream_id));
 299   context()->DispatchEvent("cast.streaming.rtpStream.onStarted", event_args);
 300 }
 301
 302 void CastStreamingNativeHandler::CallStopCallback(int stream_id) {
 303   v8::Isolate* isolate = context()->isolate();
 304   v8::HandleScope handle_scope(isolate);
 305   v8::Context::Scope context_scope(context()->v8_context());
 306   v8::Handle<v8::Array> event_args = v8::Array::New(isolate, 1);
 307   event_args->Set(0, v8::Integer::New(isolate, stream_id));
 308   context()->DispatchEvent("cast.streaming.rtpStream.onStopped", event_args);
 309 }
 310
 311 void CastStreamingNativeHandler::CallErrorCallback(int stream_id,
 312                                                    const std::string& message) {
 313   v8::Isolate* isolate = context()->isolate();
 314   v8::HandleScope handle_scope(isolate);
 315   v8::Context::Scope context_scope(context()->v8_context());
 316   v8::Handle<v8::Array> event_args = v8::Array::New(isolate, 2);
 317   event_args->Set(0, v8::Integer::New(isolate, stream_id));
 318   event_args->Set(
 319       1,
 320       v8::String::NewFromUtf8(
 321           isolate, message.data(), v8::String::kNormalString, message.size()));
 322   context()->DispatchEvent("cast.streaming.rtpStream.onError", event_args);
 323 }
 324
 325 void CastStreamingNativeHandler::DestroyCastRtpStream(
 326     const v8::FunctionCallbackInfo<v8::Value>& args) {
 327   CHECK_EQ(1, args.Length());
 328   CHECK(args[0]->IsInt32());
 329
 330   const int transport_id = args[0]->ToInt32()->Value();
 331   if (!GetRtpStreamOrThrow(transport_id))
 332     return;
 333   rtp_stream_map_.erase(transport_id);
 334 }
 335
 336 void CastStreamingNativeHandler::GetSupportedParamsCastRtpStream(
 337     const v8::FunctionCallbackInfo<v8::Value>& args) {
 338   CHECK_EQ(1, args.Length());
 339   CHECK(args[0]->IsInt32());
 340
 341   const int transport_id = args[0]->ToInt32()->Value();
 342   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
 343   if (!transport)
 344     return;
 345
 346   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 347   std::vector<CastRtpParams> cast_params = transport->GetSupportedParams();
 348   v8::Handle<v8::Array> result =
 349       v8::Array::New(args.GetIsolate(),
 350                      static_cast<int>(cast_params.size()));
 351   for (size_t i = 0; i < cast_params.size(); ++i) {
 352     RtpParams params;
 353     FromCastRtpParams(cast_params[i], &params);
 354     scoped_ptr<base::DictionaryValue> params_value = params.ToValue();
 355     result->Set(
 356         static_cast<int>(i),
 357         converter->ToV8Value(params_value.get(), context()->v8_context()));
 358   }
 359   args.GetReturnValue().Set(result);
 360 }
 361
 362 void CastStreamingNativeHandler::StartCastRtpStream(
 363     const v8::FunctionCallbackInfo<v8::Value>& args) {
 364   CHECK_EQ(2, args.Length());
 365   CHECK(args[0]->IsInt32());
 366   CHECK(args[1]->IsObject());
 367
 368   const int transport_id = args[0]->ToInt32()->Value();
 369   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
 370   if (!transport)
 371     return;
 372
 373   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 374   scoped_ptr<base::Value> params_value(
 375       converter->FromV8Value(args[1], context()->v8_context()));
 376   if (!params_value) {
 377     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
 378         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertParams)));
 379     return;
 380   }
 381   scoped_ptr<RtpParams> params = RtpParams::FromValue(*params_value);
 382   if (!params) {
 383     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
 384         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidRtpParams)));
 385     return;
 386   }
 387
 388   CastRtpParams cast_params;
 389   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
 390   if (!ToCastRtpParamsOrThrow(isolate, *params, &cast_params))
 391     return;
 392
 393   base::Closure start_callback =
 394       base::Bind(&CastStreamingNativeHandler::CallStartCallback,
 395                  weak_factory_.GetWeakPtr(),
 396                  transport_id);
 397   base::Closure stop_callback =
 398       base::Bind(&CastStreamingNativeHandler::CallStopCallback,
 399                  weak_factory_.GetWeakPtr(),
 400                  transport_id);
 401   CastRtpStream::ErrorCallback error_callback =
 402       base::Bind(&CastStreamingNativeHandler::CallErrorCallback,
 403                  weak_factory_.GetWeakPtr(),
 404                  transport_id);
 405   transport->Start(cast_params, start_callback, stop_callback, error_callback);
 406 }
 407
 408 void CastStreamingNativeHandler::StopCastRtpStream(
 409     const v8::FunctionCallbackInfo<v8::Value>& args) {
 410   CHECK_EQ(1, args.Length());
 411   CHECK(args[0]->IsInt32());
 412
 413   const int transport_id = args[0]->ToInt32()->Value();
 414   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
 415   if (!transport)
 416     return;
 417   transport->Stop();
 418 }
 419
 420 void CastStreamingNativeHandler::DestroyCastUdpTransport(
 421     const v8::FunctionCallbackInfo<v8::Value>& args) {
 422   CHECK_EQ(1, args.Length());
 423   CHECK(args[0]->IsInt32());
 424
 425   const int transport_id = args[0]->ToInt32()->Value();
 426   if (!GetUdpTransportOrThrow(transport_id))
 427     return;
 428   udp_transport_map_.erase(transport_id);
 429 }
 430
 431 void CastStreamingNativeHandler::SetDestinationCastUdpTransport(
 432     const v8::FunctionCallbackInfo<v8::Value>& args) {
 433   CHECK_EQ(2, args.Length());
 434   CHECK(args[0]->IsInt32());
 435   CHECK(args[1]->IsObject());
 436
 437   const int transport_id = args[0]->ToInt32()->Value();
 438   CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
 439   if (!transport)
 440     return;
 441
 442   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 443   scoped_ptr<base::Value> destination_value(
 444       converter->FromV8Value(args[1], context()->v8_context()));
 445   if (!destination_value) {
 446     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
 447         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
 448     return;
 449   }
 450   scoped_ptr<IPEndPoint> destination =
 451       IPEndPoint::FromValue(*destination_value);
 452   if (!destination) {
 453     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
 454         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidDestination)));
 455     return;
 456   }
 457   net::IPAddressNumber ip;
 458   if (!net::ParseIPLiteralToNumber(destination->address, &ip)) {
 459     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
 460         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidDestination)));
 461     return;
 462   }
 463   transport->SetDestination(net::IPEndPoint(ip, destination->port));
 464 }
 465
 466 void CastStreamingNativeHandler::SetOptionsCastUdpTransport(
 467     const v8::FunctionCallbackInfo<v8::Value>& args) {
 468   CHECK_EQ(2, args.Length());
 469   CHECK(args[0]->IsInt32());
 470   CHECK(args[1]->IsObject());
 471
 472   const int transport_id = args[0]->ToInt32()->Value();
 473   CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
 474   if (!transport)
 475     return;
 476
 477   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 478   base::Value* options_value =
 479       converter->FromV8Value(args[1], context()->v8_context());
 480   base::DictionaryValue* options;
 481   if (!options_value || !options_value->GetAsDictionary(&options)) {
 482     delete options_value;
 483     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
 484         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
 485     return;
 486   }
 487   transport->SetOptions(make_scoped_ptr(options));
 488 }
 489
 490 void CastStreamingNativeHandler::ToggleLogging(
 491     const v8::FunctionCallbackInfo<v8::Value>& args) {
 492   CHECK_EQ(2, args.Length());
 493   CHECK(args[0]->IsInt32());
 494   CHECK(args[1]->IsBoolean());
 495
 496   const int stream_id = args[0]->ToInt32()->Value();
 497   CastRtpStream* stream = GetRtpStreamOrThrow(stream_id);
 498   if (!stream)
 499     return;
 500
 501   const bool enable = args[1]->ToBoolean()->Value();
 502   stream->ToggleLogging(enable);
 503 }
 504
 505 void CastStreamingNativeHandler::GetRawEvents(
 506     const v8::FunctionCallbackInfo<v8::Value>& args) {
 507   CHECK_EQ(3, args.Length());
 508   CHECK(args[0]->IsInt32());
 509   CHECK(args[1]->IsNull() || args[1]->IsString());
 510   CHECK(args[2]->IsFunction());
 511
 512   const int transport_id = args[0]->ToInt32()->Value();
 513   // TODO(imcheng): Use a weak reference to ensure we don't call into an
 514   // invalid context when the callback is invoked.
 515   linked_ptr<ScopedPersistent<v8::Function> > callback(
 516       new ScopedPersistent<v8::Function>(args[2].As<v8::Function>()));
 517   std::string extra_data;
 518   if (!args[1]->IsNull()) {
 519     extra_data = *v8::String::Utf8Value(args[1]);
 520   }
 521
 522   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
 523   if (!transport)
 524     return;
 525
 526   get_raw_events_callbacks_.insert(std::make_pair(transport_id, callback));
 527
 528   transport->GetRawEvents(
 529       base::Bind(&CastStreamingNativeHandler::CallGetRawEventsCallback,
 530                  weak_factory_.GetWeakPtr(),
 531                  transport_id),
 532       extra_data);
 533 }
 534
 535 void CastStreamingNativeHandler::GetStats(
 536     const v8::FunctionCallbackInfo<v8::Value>& args) {
 537   CHECK_EQ(2, args.Length());
 538   CHECK(args[0]->IsInt32());
 539   CHECK(args[1]->IsFunction());
 540   const int transport_id = args[0]->ToInt32()->Value();
 541   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
 542   if (!transport)
 543     return;
 544
 545   // TODO(imcheng): Use a weak reference to ensure we don't call into an
 546   // invalid context when the callback is invoked.
 547   linked_ptr<ScopedPersistent<v8::Function> > callback(
 548       new ScopedPersistent<v8::Function>(args[1].As<v8::Function>()));
 549   get_stats_callbacks_.insert(std::make_pair(transport_id, callback));
 550
 551   transport->GetStats(
 552       base::Bind(&CastStreamingNativeHandler::CallGetStatsCallback,
 553                  weak_factory_.GetWeakPtr(),
 554                  transport_id));
 555 }
 556
 557 void CastStreamingNativeHandler::CallGetRawEventsCallback(
 558     int transport_id,
 559     scoped_ptr<base::BinaryValue> raw_events) {
 560   v8::Isolate* isolate = context()->isolate();
 561   v8::HandleScope handle_scope(isolate);
 562   v8::Context::Scope context_scope(context()->v8_context());
 563
 564   RtpStreamCallbackMap::iterator it =
 565       get_raw_events_callbacks_.find(transport_id);
 566   if (it == get_raw_events_callbacks_.end())
 567     return;
 568   v8::Handle<v8::Value> callback_args[1];
 569   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 570   callback_args[0] =
 571       converter->ToV8Value(raw_events.get(), context()->v8_context());
 572   context()->CallFunction(it->second->NewHandle(isolate), 1, callback_args);
 573   get_raw_events_callbacks_.erase(it);
 574 }
 575
 576 void CastStreamingNativeHandler::CallGetStatsCallback(
 577     int transport_id,
 578     scoped_ptr<base::DictionaryValue> stats) {
 579   v8::Isolate* isolate = context()->isolate();
 580   v8::HandleScope handle_scope(isolate);
 581   v8::Context::Scope context_scope(context()->v8_context());
 582
 583   RtpStreamCallbackMap::iterator it = get_stats_callbacks_.find(transport_id);
 584   if (it == get_stats_callbacks_.end())
 585     return;
 586
 587   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 588   v8::Handle<v8::Value> callback_args[1];
 589   callback_args[0] = converter->ToV8Value(stats.get(), context()->v8_context());
 590   context()->CallFunction(it->second->NewHandle(isolate), 1, callback_args);
 591   get_stats_callbacks_.erase(it);
 592 }
 593
 594 CastRtpStream* CastStreamingNativeHandler::GetRtpStreamOrThrow(
 595     int transport_id) const {
 596   RtpStreamMap::const_iterator iter = rtp_stream_map_.find(
 597       transport_id);
 598   if (iter != rtp_stream_map_.end())
 599     return iter->second.get();
 600   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
 601   isolate->ThrowException(v8::Exception::RangeError(v8::String::NewFromUtf8(
 602       isolate, kRtpStreamNotFound)));
 603   return NULL;
 604 }
 605
 606 CastUdpTransport* CastStreamingNativeHandler::GetUdpTransportOrThrow(
 607     int transport_id) const {
 608   UdpTransportMap::const_iterator iter = udp_transport_map_.find(
 609       transport_id);
 610   if (iter != udp_transport_map_.end())
 611     return iter->second.get();
 612   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
 613   isolate->ThrowException(v8::Exception::RangeError(
 614       v8::String::NewFromUtf8(isolate, kUdpTransportNotFound)));
 615   return NULL;
 616 }
 617
 618 }  // namespace extensions