Set AES key and IV mask to CastSender

chrome/renderer/extensions/cast_streaming_native_handler.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/extensions/cast_streaming_native_handler.h"
 
 #include <functional>
 
+#include "base/base64.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/common/extensions/api/cast_streaming_rtp_stream.h"
 #include "chrome/common/extensions/api/cast_streaming_udp_transport.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/media/cast_rtp_stream.h"
 #include "chrome/renderer/media/cast_session.h"
 #include "chrome/renderer/media/cast_udp_transport.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "net/base/host_port_pair.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/web/WebDOMMediaStreamTrack.h"
 
 using content::V8ValueConverter;
 
 // Extension types.
 using extensions::api::cast_streaming_rtp_stream::CodecSpecificParams;
 using extensions::api::cast_streaming_rtp_stream::RtpCaps;
 using extensions::api::cast_streaming_rtp_stream::RtpParams;
 using extensions::api::cast_streaming_rtp_stream::RtpPayloadParams;
 using extensions::api::cast_streaming_udp_transport::UdpParams;
 
 namespace extensions {
 
 namespace {
 const char kRtpStreamNotFound[] = "The RTP stream cannot be found";
 const char kUdpTransportNotFound[] = "The UDP transport cannot be found";
 const char kInvalidUdpParams[] = "Invalid UDP params";
 const char kInvalidRtpParams[] = "Invalid value for RTP params";
+const char kInvalidAesKey[] = "Invalid value for AES key";
+const char kInvalidAesIvMask[] = "Invalid value for AES IV mask";
 const char kUnableToConvertArgs[] = "Unable to convert arguments";
 const char kUnableToConvertParams[] = "Unable to convert params";
 
 // These helper methods are used to convert between Extension API
 // types and Cast types.
 void ToCastCodecSpecificParams(const CodecSpecificParams& ext_params,
                                CastCodecSpecificParams* cast_params) {
   cast_params->key = ext_params.key;
   cast_params->value = ext_params.value;
 }
 
 void FromCastCodecSpecificParams(const CastCodecSpecificParams& cast_params,
                                  CodecSpecificParams* ext_params) {
   ext_params->key = cast_params.key;
   ext_params->value = cast_params.value;
 }
 
-void ToCastRtpPayloadParams(const RtpPayloadParams& ext_params,
-                            CastRtpPayloadParams* cast_params) {
+bool ToCastRtpPayloadParamsOrThrow(v8::Isolate* isolate,
+                                   const RtpPayloadParams& ext_params,
+                                   CastRtpPayloadParams* cast_params) {
   cast_params->payload_type = ext_params.payload_type;
   cast_params->codec_name = ext_params.codec_name;
   cast_params->ssrc = ext_params.ssrc ? *ext_params.ssrc : 0;
   cast_params->feedback_ssrc =
       ext_params.feedback_ssrc ? *ext_params.feedback_ssrc : 0;
   cast_params->clock_rate = ext_params.clock_rate ? *ext_params.clock_rate : 0;
   cast_params->min_bitrate =
       ext_params.min_bitrate ? *ext_params.min_bitrate : 0;
   cast_params->max_bitrate =
       ext_params.max_bitrate ? *ext_params.max_bitrate : 0;
   cast_params->channels = ext_params.channels ? *ext_params.channels : 0;
   cast_params->width = ext_params.width ? *ext_params.width : 0;
   cast_params->height = ext_params.height ? *ext_params.height : 0;
+  if (ext_params.aes_key &&
+      !base::Base64Decode(*ext_params.aes_key, &cast_params->aes_key)) {
+    isolate->ThrowException(v8::Exception::Error(
+        v8::String::NewFromUtf8(isolate, kInvalidAesKey)));
+    return false;
+  }
+  if (ext_params.aes_iv_mask &&
+      !base::Base64Decode(*ext_params.aes_iv_mask,
+                          &cast_params->aes_iv_mask)) {
+    isolate->ThrowException(v8::Exception::Error(
+        v8::String::NewFromUtf8(isolate, kInvalidAesIvMask)));
+    return false;
+  }
   for (size_t i = 0; i < ext_params.codec_specific_params.size(); ++i) {
     CastCodecSpecificParams cast_codec_params;
     ToCastCodecSpecificParams(*ext_params.codec_specific_params[i],
                               &cast_codec_params);
     cast_params->codec_specific_params.push_back(cast_codec_params);
   }
+  return true;
 }
 
 void FromCastRtpPayloadParams(const CastRtpPayloadParams& cast_params,
                               RtpPayloadParams* ext_params) {
   ext_params->payload_type = cast_params.payload_type;
   ext_params->codec_name = cast_params.codec_name;
   if (cast_params.ssrc)
     ext_params->ssrc.reset(new int(cast_params.ssrc));
   if (cast_params.feedback_ssrc)
     ext_params->feedback_ssrc.reset(new int(cast_params.feedback_ssrc));
@@ skipping 21 matching lines @@
 void FromCastRtpCaps(const CastRtpCaps& cast_caps, RtpCaps* ext_caps) {
   std::copy(cast_caps.rtcp_features.begin(), cast_caps.rtcp_features.end(),
             ext_caps->rtcp_features.begin());
   for (size_t i = 0; i < cast_caps.payloads.size(); ++i) {
     linked_ptr<RtpPayloadParams> ext_payload_params(new RtpPayloadParams());
     FromCastRtpPayloadParams(cast_caps.payloads[i], ext_payload_params.get());
     ext_caps->payloads.push_back(ext_payload_params);
   }
 }
 
-void ToCastRtpParams(const RtpParams& ext_params, CastRtpParams* cast_params) {
+bool ToCastRtpParamsOrThrow(v8::Isolate* isolate,
+                            const RtpParams& ext_params,
+                            CastRtpParams* cast_params) {
   std::copy(ext_params.rtcp_features.begin(), ext_params.rtcp_features.end(),
             cast_params->rtcp_features.begin());
   for (size_t i = 0; i < ext_params.payloads.size(); ++i) {
     CastRtpPayloadParams cast_payload_params;
-    ToCastRtpPayloadParams(*ext_params.payloads[i], &cast_payload_params);
+    if (!ToCastRtpPayloadParamsOrThrow(isolate,
+                                       *ext_params.payloads[i],
+                                       &cast_payload_params)) {
+      return false;
+    }
     cast_params->payloads.push_back(cast_payload_params);
   }
+  return true;
 }
 
 }  // namespace
 
 CastStreamingNativeHandler::CastStreamingNativeHandler(ChromeV8Context* context)
     : ObjectBackedNativeHandler(context),
       last_transport_id_(0),
       weak_factory_(this) {
   RouteFunction("CreateSession",
       base::Bind(&CastStreamingNativeHandler::CreateCastSession,
@@ skipping 135 matching lines @@
     return;
   }
   scoped_ptr<RtpParams> params = RtpParams::FromValue(*params_value);
   if (!params) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidRtpParams)));
     return;
   }
 
   CastRtpCaps cast_params;
-  ToCastRtpParams(*params, &cast_params);
+  v8::Isolate* isolate = context()->v8_context()->GetIsolate();
+  if (!ToCastRtpParamsOrThrow(isolate, *params, &cast_params))
+    return;
   transport->Start(cast_params);
 }
 
 void CastStreamingNativeHandler::StopCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
   const int transport_id = args[0]->ToInt32()->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
@@ skipping 65 matching lines @@
       transport_id);
   if (iter != udp_transport_map_.end())
     return iter->second.get();
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
   isolate->ThrowException(v8::Exception::RangeError(
       v8::String::NewFromUtf8(isolate, kUdpTransportNotFound)));
   return NULL;
 }
 
 }  // namespace extensions