Adding CastRemotingSender for media remoting.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 14 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/common/extensions/api/cast_streaming_receiver_session.h"
 #include "chrome/common/extensions/api/cast_streaming_rtp_stream.h"
 #include "chrome/common/extensions/api/cast_streaming_udp_transport.h"
 #include "chrome/renderer/media/cast_receiver_session.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/child/v8_value_converter.h"
 #include "content/public/renderer/media_stream_utils.h"
+#include "extensions/common/extension.h"
 #include "extensions/renderer/script_context.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/limits.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/ip_address.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDOMMediaStreamTrack.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
@@ skipping 22 matching lines @@
 constexpr char kInvalidLatency[] = "Invalid value for max_latency. (0-1000)";
 constexpr char kInvalidRtpTimebase[] = "Invalid rtp_timebase. (1000-1000000)";
 constexpr char kInvalidStreamArgs[] = "Invalid stream arguments";
 constexpr char kRtpStreamNotFound[] = "The RTP stream cannot be found";
 constexpr char kUdpTransportNotFound[] = "The UDP transport cannot be found";
 constexpr char kUnableToConvertArgs[] = "Unable to convert arguments";
 constexpr char kUnableToConvertParams[] = "Unable to convert params";
 constexpr char kCodecNameOpus[] = "OPUS";
 constexpr char kCodecNameVp8[] = "VP8";
 constexpr char kCodecNameH264[] = "H264";
+constexpr char kCodecNameRemoteAudio[] = "REMOTE_AUDIO";
+constexpr char kCodecNameRemoteVideo[] = "REMOTE_VIDEO";
 
 // To convert from kilobits per second to bits per second.
 constexpr int kBitsPerKilobit = 1000;
 
 bool HexDecode(const std::string& input, std::string* output) {
   std::vector<uint8_t> bytes;
   if (!base::HexStringToBytes(input, &bytes))
     return false;
   output->assign(reinterpret_cast<const char*>(&bytes[0]), bytes.size());
   return true;
@@ skipping 119 matching lines @@
           CastRtpStream::IsHardwareVP8EncodingSupported();
     } else {
       config->rtp_payload_type = media::cast::RtpPayloadType::VIDEO_H264;
       config->codec = media::cast::CODEC_VIDEO_H264;
       config->use_external_encoder =
           CastRtpStream::IsHardwareH264EncodingSupported();
     }
     if (!config->use_external_encoder)
       config->video_codec_params.number_of_encode_threads =
           NumberOfEncodeThreads();
+  } else if (ext_params.codec_name == kCodecNameRemoteAudio) {
+    config->rtp_payload_type = media::cast::RtpPayloadType::REMOTE_AUDIO;
+    config->codec = media::cast::CODEC_AUDIO_REMOTE;
+  } else if (ext_params.codec_name == kCodecNameRemoteVideo) {
+    config->rtp_payload_type = media::cast::RtpPayloadType::REMOTE_VIDEO;
+    config->codec = media::cast::CODEC_VIDEO_REMOTE;
   } else {
     DVLOG(1) << "codec_name " << ext_params.codec_name << " is invalid";
     isolate->ThrowException(v8::Exception::Error(
         v8::String::NewFromUtf8(isolate, kInvalidRtpParams)));
     return false;
   }
   if (ext_params.aes_key && !HexDecode(*ext_params.aes_key, &config->aes_key)) {
     isolate->ThrowException(v8::Exception::Error(
         v8::String::NewFromUtf8(isolate, kInvalidAesKey)));
     return false;
@@ skipping 18 matching lines @@
   switch (config.codec) {
     case media::cast::CODEC_AUDIO_OPUS:
       ext_params->codec_name = kCodecNameOpus;
       break;
     case media::cast::CODEC_VIDEO_VP8:
       ext_params->codec_name = kCodecNameVp8;
       break;
     case media::cast::CODEC_VIDEO_H264:
       ext_params->codec_name = kCodecNameH264;
       break;
+    case media::cast::CODEC_AUDIO_REMOTE:
+      ext_params->codec_name = kCodecNameRemoteAudio;
+      break;
+    case media::cast::CODEC_VIDEO_REMOTE:
+      ext_params->codec_name = kCodecNameRemoteVideo;
+      break;
     default:
       NOTREACHED();
   }
   ext_params->ssrc = config.sender_ssrc;
   ext_params->feedback_ssrc = config.receiver_ssrc;
   if (config.rtp_timebase)
     ext_params->clock_rate.reset(new int(config.rtp_timebase));
   if (config.min_bitrate)
     ext_params->min_bitrate.reset(
         new int(config.min_bitrate / kBitsPerKilobit));
   if (config.max_bitrate)
     ext_params->max_bitrate.reset(
         new int(config.max_bitrate / kBitsPerKilobit));
   if (config.channels)
     ext_params->channels.reset(new int(config.channels));
   if (config.max_frame_rate > 0.0)
     ext_params->max_frame_rate.reset(new double(config.max_frame_rate));
 }
 
 }  // namespace
 
+// |last_transport_id_| is the identifier for the next created RTP stream. To
+// create globally unique IDs used for referring to RTP stream objects in
+// browser process, we set its higher 16 bits as HASH(extension_id)&0x7fff, and
+// lower 16 bits as the sequence number of the RTP stream created in the same
+// extension. Collision will happen when the first RTP stream keeps alive after
+// creating another 64k-1 RTP streams in the same extension, which is very
+// unlikely to happen in normal use cases.
 CastStreamingNativeHandler::CastStreamingNativeHandler(ScriptContext* context)
     : ObjectBackedNativeHandler(context),
-      last_transport_id_(1),
+      last_transport_id_(
+          context->extension()
+              ? (((base::Hash(context->extension()->id()) & 0x7fff) << 16) + 1)
+              : 1),
       weak_factory_(this) {
   RouteFunction("CreateSession", "cast.streaming.session",
                 base::Bind(&CastStreamingNativeHandler::CreateCastSession,
                            weak_factory_.GetWeakPtr()));
   RouteFunction("DestroyCastRtpStream", "cast.streaming.rtpStream",
                 base::Bind(&CastStreamingNativeHandler::DestroyCastRtpStream,
                            weak_factory_.GetWeakPtr()));
   RouteFunction(
       "GetSupportedParamsCastRtpStream", "cast.streaming.rtpStream",
       base::Bind(&CastStreamingNativeHandler::GetSupportedParamsCastRtpStream,
@@ skipping 48 matching lines @@
 
   ObjectBackedNativeHandler::Invalidate();
 }
 
 void CastStreamingNativeHandler::CreateCastSession(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(3, args.Length());
   CHECK(args[2]->IsFunction());
 
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
-  if ((args[0]->IsNull() || args[0]->IsUndefined()) &&
-      (args[1]->IsNull() || args[1]->IsUndefined())) {
-    isolate->ThrowException(v8::Exception::Error(
-        v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
-    return;
-  }
 
   scoped_refptr<CastSession> session(new CastSession());
   std::unique_ptr<CastRtpStream> stream1, stream2;
-  if (!args[0]->IsNull() && !args[0]->IsUndefined()) {
-    CHECK(args[0]->IsObject());
-    blink::WebDOMMediaStreamTrack track =
-        blink::WebDOMMediaStreamTrack::fromV8Value(args[0]);
-    if (track.isNull()) {
-      isolate->ThrowException(v8::Exception::Error(
-          v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
-      return;
+  if ((args[0]->IsNull() || args[0]->IsUndefined()) &&
+      (args[1]->IsNull() || args[1]->IsUndefined())) {
+    DVLOG(3) << "CreateCastSession for remoting.";
+    // Creates audio/video RTP streams for media remoting.
+    stream1.reset(new CastRtpStream(true, session));
+    stream2.reset(new CastRtpStream(false, session));
+  } else {
+    // Creates RTP streams that consume from an audio and/or a video
+    // MediaStreamTrack.
+    if (!args[0]->IsNull() && !args[0]->IsUndefined()) {
+      CHECK(args[0]->IsObject());
+      blink::WebDOMMediaStreamTrack track =
+          blink::WebDOMMediaStreamTrack::fromV8Value(args[0]);
+      if (track.isNull()) {
+        isolate->ThrowException(v8::Exception::Error(
+            v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
+        return;
+      }
+      stream1.reset(new CastRtpStream(track.component(), session));
     }
-    stream1.reset(new CastRtpStream(track.component(), session));
-  }
-  if (!args[1]->IsNull() && !args[1]->IsUndefined()) {
-    CHECK(args[1]->IsObject());
-    blink::WebDOMMediaStreamTrack track =
-        blink::WebDOMMediaStreamTrack::fromV8Value(args[1]);
-    if (track.isNull()) {
-      isolate->ThrowException(v8::Exception::Error(
-          v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
-      return;
+    if (!args[1]->IsNull() && !args[1]->IsUndefined()) {
+      CHECK(args[1]->IsObject());
+      blink::WebDOMMediaStreamTrack track =
+          blink::WebDOMMediaStreamTrack::fromV8Value(args[1]);
+      if (track.isNull()) {
+        isolate->ThrowException(v8::Exception::Error(
+            v8::String::NewFromUtf8(isolate, kInvalidStreamArgs)));
+        return;
+      }
+      stream2.reset(new CastRtpStream(track.component(), session));
     }
-    stream2.reset(new CastRtpStream(track.component(), session));
   }
   std::unique_ptr<CastUdpTransport> udp_transport(
       new CastUdpTransport(session));
 
   create_callback_.Reset(isolate, args[2].As<v8::Function>());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CastStreamingNativeHandler::CallCreateCallback,
                  weak_factory_.GetWeakPtr(), base::Passed(&stream1),
@@ skipping 136 matching lines @@
                  weak_factory_.GetWeakPtr(),
                  transport_id);
   base::Closure stop_callback =
       base::Bind(&CastStreamingNativeHandler::CallStopCallback,
                  weak_factory_.GetWeakPtr(),
                  transport_id);
   CastRtpStream::ErrorCallback error_callback =
       base::Bind(&CastStreamingNativeHandler::CallErrorCallback,
                  weak_factory_.GetWeakPtr(),
                  transport_id);
-  transport->Start(config, start_callback, stop_callback, error_callback);
+
+  // |transport_id| is a globally unique identifier for the RTP stream.
+  transport->Start(transport_id, config, start_callback, stop_callback,
+                   error_callback);
 }
 
 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(args.GetIsolate())->Value();
   CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
@@ skipping 419 matching lines @@
     LOG(ERROR) << "Failed to add Cast audio track to media stream.";
   }
   if (!content::AddVideoTrackToMediaStream(std::move(video), true,  // is_remote
                                            true,  // is_readonly
                                            &web_stream)) {
     LOG(ERROR) << "Failed to add Cast video track to media stream.";
   }
 }
 
 }  // namespace extensions