Rename some Cast Streaming APIs

Rename done in this change:
chrome.cast.streaming.start -> chrome.cast.streaming.setDestination
chrome.cast.rtpStream.getCaps ->
    chrome.cast.rtpStream.getSupportedParams

Also removed the dictionary of CastRtpCaps. And now there's just one
CastRtpParams.

Review URL: https://codereview.chromium.org/137003003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@245729 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 105 insertions, 105 deletions

diff --git a/chrome/renderer/extensions/cast_streaming_native_handler.cc b/chrome/renderer/extensions/cast_streaming_native_handler.cc
index dcc1ede..8170f63 100644
--- a/chrome/renderer/extensions/cast_streaming_native_handler.cc
+++ b/chrome/renderer/extensions/cast_streaming_native_handler.cc
@@ -24,17 +24,16 @@ 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;
+using extensions::api::cast_streaming_udp_transport::IPEndPoint;
 
 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 kInvalidDestination[] = "Invalid destination";
 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";
@@ -122,14 +121,11 @@ void FromCastRtpPayloadParams(const CastRtpPayloadParams& cast_params,
   }
 }
 
-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 FromCastRtpParams(const CastRtpParams& cast_params,
+                       RtpParams* ext_params) {
+  std::copy(cast_params.rtcp_features.begin(), cast_params.rtcp_features.end(),
+            ext_params->rtcp_features.begin());
+  FromCastRtpPayloadParams(cast_params.payload, &ext_params->payload);
 }
 
 bool ToCastRtpParamsOrThrow(v8::Isolate* isolate,
@@ -137,14 +133,10 @@ bool ToCastRtpParamsOrThrow(v8::Isolate* isolate,
                             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;
-    if (!ToCastRtpPayloadParamsOrThrow(isolate,
-                                       *ext_params.payloads[i],
-                                       &cast_payload_params)) {
-      return false;
-    }
-    cast_params->payloads.push_back(cast_payload_params);
+  if (!ToCastRtpPayloadParamsOrThrow(isolate,
+                                     ext_params.payload,
+                                     &cast_params->payload)) {
+    return false;
   }
   return true;
 }
@@ -161,8 +153,8 @@ CastStreamingNativeHandler::CastStreamingNativeHandler(ChromeV8Context* context)
   RouteFunction("DestroyCastRtpStream",
       base::Bind(&CastStreamingNativeHandler::DestroyCastRtpStream,
                  base::Unretained(this)));
-  RouteFunction("GetCapsCastRtpStream",
-      base::Bind(&CastStreamingNativeHandler::GetCapsCastRtpStream,
+  RouteFunction("GetSupportedParamsCastRtpStream",
+      base::Bind(&CastStreamingNativeHandler::GetSupportedParamsCastRtpStream,
                  base::Unretained(this)));
   RouteFunction("StartCastRtpStream",
       base::Bind(&CastStreamingNativeHandler::StartCastRtpStream,
@@ -173,8 +165,8 @@ CastStreamingNativeHandler::CastStreamingNativeHandler(ChromeV8Context* context)
   RouteFunction("DestroyCastUdpTransport",
       base::Bind(&CastStreamingNativeHandler::DestroyCastUdpTransport,
                  base::Unretained(this)));
-  RouteFunction("StartCastUdpTransport",
-      base::Bind(&CastStreamingNativeHandler::StartCastUdpTransport,
+  RouteFunction("SetDestinationCastUdpTransport",
+      base::Bind(&CastStreamingNativeHandler::SetDestinationCastUdpTransport,
                  base::Unretained(this)));
 }
 
@@ -255,7 +247,7 @@ void CastStreamingNativeHandler::DestroyCastRtpStream(
   rtp_stream_map_.erase(transport_id);
 }
 
-void CastStreamingNativeHandler::GetCapsCastRtpStream(
+void CastStreamingNativeHandler::GetSupportedParamsCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
@@ -265,14 +257,20 @@ void CastStreamingNativeHandler::GetCapsCastRtpStream(
   if (!transport)
     return;
 
-  CastRtpCaps cast_caps = transport->GetCaps();
-  RtpCaps caps;
-  FromCastRtpCaps(cast_caps, &caps);
-
-  scoped_ptr<base::DictionaryValue> caps_value = caps.ToValue();
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  args.GetReturnValue().Set(converter->ToV8Value(
-      caps_value.get(), context()->v8_context()));
+  std::vector<CastRtpParams> cast_params = transport->GetSupportedParams();
+  v8::Handle<v8::Array> result =
+      v8::Array::New(args.GetIsolate(),
+                     static_cast<int>(cast_params.size()));
+  for (size_t i = 0; i < cast_params.size(); ++i) {
+    RtpParams params;
+    FromCastRtpParams(cast_params[i], &params);
+    scoped_ptr<base::DictionaryValue> params_value = params.ToValue();
+    result->Set(
+        static_cast<int>(i),
+        converter->ToV8Value(params_value.get(), context()->v8_context()));
+  }
+  args.GetReturnValue().Set(result);
 }
 
 void CastStreamingNativeHandler::StartCastRtpStream(
@@ -301,7 +299,7 @@ void CastStreamingNativeHandler::StartCastRtpStream(
     return;
   }
 
-  CastRtpCaps cast_params;
+  CastRtpParams cast_params;
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
   if (!ToCastRtpParamsOrThrow(isolate, *params, &cast_params))
     return;
@@ -331,7 +329,7 @@ void CastStreamingNativeHandler::DestroyCastUdpTransport(
   udp_transport_map_.erase(transport_id);
 }
 
-void CastStreamingNativeHandler::StartCastUdpTransport(
+void CastStreamingNativeHandler::SetDestinationCastUdpTransport(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
@@ -343,26 +341,27 @@ void CastStreamingNativeHandler::StartCastUdpTransport(
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-  scoped_ptr<base::Value> udp_params_value(
+  scoped_ptr<base::Value> destination_value(
       converter->FromV8Value(args[1], context()->v8_context()));
-  if (!udp_params_value) {
+  if (!destination_value) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
     return;
   }
-  scoped_ptr<UdpParams> udp_params = UdpParams::FromValue(*udp_params_value);
-  if (!udp_params) {
+  scoped_ptr<IPEndPoint> destination =
+      IPEndPoint::FromValue(*destination_value);
+  if (!destination) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
-        v8::String::NewFromUtf8(args.GetIsolate(), kInvalidUdpParams)));
+        v8::String::NewFromUtf8(args.GetIsolate(), kInvalidDestination)));
     return;
   }
   net::IPAddressNumber ip;
-  if (!net::ParseIPLiteralToNumber(udp_params->address, &ip)) {
+  if (!net::ParseIPLiteralToNumber(destination->address, &ip)) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
-        v8::String::NewFromUtf8(args.GetIsolate(), kInvalidUdpParams)));
+        v8::String::NewFromUtf8(args.GetIsolate(), kInvalidDestination)));
     return;
   }
-  transport->Start(net::IPEndPoint(ip, udp_params->port));
+  transport->SetDestination(net::IPEndPoint(ip, destination->port));
 }
 
 CastRtpStream* CastStreamingNativeHandler::GetRtpStreamOrThrow(
diff --git a/chrome/renderer/extensions/cast_streaming_native_handler.h b/chrome/renderer/extensions/cast_streaming_native_handler.h
index 4c2360c..02d8efa 100644
--- a/chrome/renderer/extensions/cast_streaming_native_handler.h
+++ b/chrome/renderer/extensions/cast_streaming_native_handler.h
@@ -34,7 +34,7 @@ class CastStreamingNativeHandler : public ObjectBackedNativeHandler {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   void CreateParamsCastRtpStream(
       const v8::FunctionCallbackInfo<v8::Value>& args);
-  void GetCapsCastRtpStream(
+  void GetSupportedParamsCastRtpStream(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   void StartCastRtpStream(
       const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -43,7 +43,7 @@ class CastStreamingNativeHandler : public ObjectBackedNativeHandler {
 
   void DestroyCastUdpTransport(
       const v8::FunctionCallbackInfo<v8::Value>& args);
-  void StartCastUdpTransport(
+  void SetDestinationCastUdpTransport(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   void StopCastUdpTransport(
       const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/chrome/renderer/media/cast_rtp_stream.cc b/chrome/renderer/media/cast_rtp_stream.cc
index 66ac92a..54ea870 100644
--- a/chrome/renderer/media/cast_rtp_stream.cc
+++ b/chrome/renderer/media/cast_rtp_stream.cc
@@ -52,36 +52,33 @@ CastRtpPayloadParams DefaultVp8Payload() {
   return payload;
 }
 
-CastRtpCaps DefaultAudioCaps() {
-  CastRtpCaps caps;
-  caps.payloads.push_back(DefaultOpusPayload());
-  // TODO(hclam): Fill in |rtcp_features|.
-  return caps;
+std::vector<CastRtpParams> SupportedAudioParams() {
+  // TODO(hclam): Fill in more codecs here.
+  std::vector<CastRtpParams> supported_params;
+  supported_params.push_back(CastRtpParams(DefaultOpusPayload()));
+  return supported_params;
 }
 
-CastRtpCaps DefaultVideoCaps() {
-  CastRtpCaps caps;
-  caps.payloads.push_back(DefaultVp8Payload());
-  // TODO(hclam): Fill in |rtcp_features|.
-  return caps;
+std::vector<CastRtpParams> SupportedVideoParams() {
+  // TODO(hclam): Fill in H264 here.
+  std::vector<CastRtpParams> supported_params;
+  supported_params.push_back(CastRtpParams(DefaultVp8Payload()));
+  return supported_params;
 }
 
 bool ToAudioSenderConfig(const CastRtpParams& params,
                          AudioSenderConfig* config) {
-  if (params.payloads.empty())
-    return false;
-  const CastRtpPayloadParams& payload_params = params.payloads[0];
-  config->sender_ssrc = payload_params.ssrc;
-  config->incoming_feedback_ssrc = payload_params.feedback_ssrc;
-  config->rtp_payload_type = payload_params.payload_type;
+  config->sender_ssrc = params.payload.ssrc;
+  config->incoming_feedback_ssrc = params.payload.feedback_ssrc;
+  config->rtp_payload_type = params.payload.payload_type;
   config->use_external_encoder = false;
-  config->frequency = payload_params.clock_rate;
-  config->channels = payload_params.channels;
-  config->bitrate = payload_params.max_bitrate;
-  config->aes_key = payload_params.aes_key;
-  config->aes_iv_mask = payload_params.aes_iv_mask;
+  config->frequency = params.payload.clock_rate;
+  config->channels = params.payload.channels;
+  config->bitrate = params.payload.max_bitrate;
+  config->aes_key = params.payload.aes_key;
+  config->aes_iv_mask = params.payload.aes_iv_mask;
   config->codec = media::cast::transport::kPcm16;
-  if (payload_params.codec_name == kCodecNameOpus)
+  if (params.payload.codec_name == kCodecNameOpus)
     config->codec = media::cast::transport::kOpus;
   else
     return false;
@@ -90,20 +87,17 @@ bool ToAudioSenderConfig(const CastRtpParams& params,
 
 bool ToVideoSenderConfig(const CastRtpParams& params,
                          VideoSenderConfig* config) {
-  if (params.payloads.empty())
-    return false;
-  const CastRtpPayloadParams& payload_params = params.payloads[0];
-  config->sender_ssrc = payload_params.ssrc;
-  config->incoming_feedback_ssrc = payload_params.feedback_ssrc;
-  config->rtp_payload_type = payload_params.payload_type;
+  config->sender_ssrc = params.payload.ssrc;
+  config->incoming_feedback_ssrc = params.payload.feedback_ssrc;
+  config->rtp_payload_type = params.payload.payload_type;
   config->use_external_encoder = false;
-  config->width = payload_params.width;
-  config->height = payload_params.height;
-  config->min_bitrate = config->start_bitrate = payload_params.min_bitrate;
-  config->max_bitrate = payload_params.max_bitrate;
-  config->aes_key = payload_params.aes_key;
-  config->aes_iv_mask = payload_params.aes_iv_mask;
-  if (payload_params.codec_name == kCodecNameVp8)
+  config->width = params.payload.width;
+  config->height = params.payload.height;
+  config->min_bitrate = config->start_bitrate = params.payload.min_bitrate;
+  config->max_bitrate = params.payload.max_bitrate;
+  config->aes_key = params.payload.aes_key;
+  config->aes_iv_mask = params.payload.aes_iv_mask;
+  if (params.payload.codec_name == kCodecNameVp8)
     config->codec = media::cast::transport::kVp8;
   else
     return false;
@@ -217,6 +211,10 @@ class CastAudioSink : public base::SupportsWeakPtr<CastAudioSink>,
   DISALLOW_COPY_AND_ASSIGN(CastAudioSink);
 };
 
+CastRtpParams::CastRtpParams(const CastRtpPayloadParams& payload_params)
+  : payload(payload_params) {
+}
+
 CastCodecSpecificParams::CastCodecSpecificParams() {
 }
 
@@ -238,10 +236,10 @@ CastRtpPayloadParams::CastRtpPayloadParams()
 CastRtpPayloadParams::~CastRtpPayloadParams() {
 }
 
-CastRtpCaps::CastRtpCaps() {
+CastRtpParams::CastRtpParams() {
 }
 
-CastRtpCaps::~CastRtpCaps() {
+CastRtpParams::~CastRtpParams() {
 }
 
 CastRtpStream::CastRtpStream(
@@ -254,11 +252,11 @@ CastRtpStream::CastRtpStream(
 CastRtpStream::~CastRtpStream() {
 }
 
-CastRtpCaps CastRtpStream::GetCaps() {
+std::vector<CastRtpParams> CastRtpStream::GetSupportedParams() {
   if (IsAudio())
-    return DefaultAudioCaps();
+    return SupportedAudioParams();
   else
-    return DefaultVideoCaps();
+    return SupportedVideoParams();
 }
 
 CastRtpParams CastRtpStream::GetParams() {
diff --git a/chrome/renderer/media/cast_rtp_stream.h b/chrome/renderer/media/cast_rtp_stream.h
index 00c94fd..a9fe5ed 100644
--- a/chrome/renderer/media/cast_rtp_stream.h
+++ b/chrome/renderer/media/cast_rtp_stream.h
@@ -69,20 +69,20 @@ struct CastRtpPayloadParams {
   ~CastRtpPayloadParams();
 };
 
-// Defines the capabilities of the transport.
-struct CastRtpCaps {
-  // Defines a list of supported payloads.
-  std::vector<CastRtpPayloadParams> payloads;
+// Defines the parameters of a RTP stream.
+struct CastRtpParams {
+  explicit CastRtpParams(const CastRtpPayloadParams& payload_params);
+
+  // Payload parameters.
+  CastRtpPayloadParams payload;
 
   // Names of supported RTCP features.
   std::vector<std::string> rtcp_features;
 
-  CastRtpCaps();
-  ~CastRtpCaps();
+  CastRtpParams();
+  ~CastRtpParams();
 };
 
-typedef CastRtpCaps CastRtpParams;
-
 // This object represents a RTP stream that encodes and optionally
 // encrypt audio or video data from a WebMediaStreamTrack.
 // Note that this object does not actually output packets. It allows
@@ -94,10 +94,10 @@ class CastRtpStream {
                 const scoped_refptr<CastSession>& session);
   ~CastRtpStream();
 
-  // Return capabilities currently supported by this transport.
-  CastRtpCaps GetCaps();
+  // Return parameters currently supported by this stream.
+  std::vector<CastRtpParams> GetSupportedParams();
 
-  // Return parameters set to this transport.
+  // Return parameters set to this stream.
   CastRtpParams GetParams();
 
   // Begin encoding of media stream and then submit the encoded streams
diff --git a/chrome/renderer/media/cast_session_delegate.cc b/chrome/renderer/media/cast_session_delegate.cc
index 7ad7a68..86bbf46 100644
--- a/chrome/renderer/media/cast_session_delegate.cc
+++ b/chrome/renderer/media/cast_session_delegate.cc
@@ -39,14 +39,13 @@ void CastSessionDelegate::StartAudio(
   audio_configured_ = true;
   audio_config_ = config;
   frame_input_available_callbacks_.push_back(callback);
+  StartSendingInternal();
 }
 
 void CastSessionDelegate::StartSending(const SendPacketCallback& callback) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   send_packet_callback_ = callback;
-  if (!audio_configured_ || !video_configured_)
-    return;
   StartSendingInternal();
 }
 
@@ -58,6 +57,7 @@ void CastSessionDelegate::StartVideo(
   video_configured_ = true;
   video_config_ = config;
   frame_input_available_callbacks_.push_back(callback);
+  StartSendingInternal();
 }
 
 void CastSessionDelegate::StartSendingInternal() {
@@ -65,6 +65,8 @@ void CastSessionDelegate::StartSendingInternal() {
 
   if (cast_environment_)
     return;
+  if (!audio_configured_ || !video_configured_)
+    return;
 
   audio_encode_thread_.Start();
   video_encode_thread_.Start();
@@ -102,6 +104,8 @@ void CastSessionDelegate::StartSendingInternal() {
 // media::cast::PacketSender Implementation
 bool CastSessionDelegate::SendPacket(
     const media::cast::Packet& packet) {
+  if (send_packet_callback_.is_null())
+    return false;
   send_packet_callback_.Run(
       *reinterpret_cast<const std::vector<char> *>(&packet));
   return true;
diff --git a/chrome/renderer/media/cast_udp_transport.cc b/chrome/renderer/media/cast_udp_transport.cc
index 4ef9ffd..fd4438d 100644
--- a/chrome/renderer/media/cast_udp_transport.cc
+++ b/chrome/renderer/media/cast_udp_transport.cc
@@ -22,7 +22,7 @@ CastUdpTransport::~CastUdpTransport() {
     socket_->Close();
 }
 
-void CastUdpTransport::Start(const net::IPEndPoint& remote_address) {
+void CastUdpTransport::SetDestination(const net::IPEndPoint& remote_address) {
   remote_address_ = remote_address;
   // TODO(hclam): This code binds to a fixed port for now. P2P socket will be
   // deprecated once we move packet sending to the browser and this code
diff --git a/chrome/renderer/media/cast_udp_transport.h b/chrome/renderer/media/cast_udp_transport.h
index f6b2deb..4b1a0b8 100644
--- a/chrome/renderer/media/cast_udp_transport.h
+++ b/chrome/renderer/media/cast_udp_transport.h
@@ -22,9 +22,8 @@ class CastUdpTransport : public content::P2PSocketClientDelegate {
   explicit CastUdpTransport(const scoped_refptr<CastSession>& session);
   virtual ~CastUdpTransport();
 
-  // Begin the transport by specifying the remote IP address.
-  // The transport will use UDP.
-  void Start(const net::IPEndPoint& remote_address);
+  // Specify the remote IP address and port.
+  void SetDestination(const net::IPEndPoint& remote_address);
 
  protected:
   // content::P2PSocketClient::Delegate Implementation
diff --git a/chrome/renderer/resources/extensions/cast_streaming_rtp_stream_custom_bindings.js b/chrome/renderer/resources/extensions/cast_streaming_rtp_stream_custom_bindings.js
index 8feb8dd..0e054b5 100644
--- a/chrome/renderer/resources/extensions/cast_streaming_rtp_stream_custom_bindings.js
+++ b/chrome/renderer/resources/extensions/cast_streaming_rtp_stream_custom_bindings.js
@@ -14,9 +14,9 @@ binding.registerCustomHook(function(bindingsAPI, extensionId) {
       function(transportId) {
         natives.DestroyCastRtpStream(transportId);
   });
-  apiFunctions.setHandleRequest('getCaps',
+  apiFunctions.setHandleRequest('getSupportedParams',
       function(transportId) {
-        return natives.GetCapsCastRtpStream(transportId);
+        return natives.GetSupportedParamsCastRtpStream(transportId);
   });
   apiFunctions.setHandleRequest('start',
       function(transportId, params) {
diff --git a/chrome/renderer/resources/extensions/cast_streaming_udp_transport_custom_bindings.js b/chrome/renderer/resources/extensions/cast_streaming_udp_transport_custom_bindings.js
index a29b321..7bc483a 100644
--- a/chrome/renderer/resources/extensions/cast_streaming_udp_transport_custom_bindings.js
+++ b/chrome/renderer/resources/extensions/cast_streaming_udp_transport_custom_bindings.js
@@ -13,9 +13,9 @@ binding.registerCustomHook(function(bindingsAPI, extensionId) {
   apiFunctions.setHandleRequest('destroy', function(transportId) {
     natives.DestroyCastUdpTransport(transportId);
   });
-  apiFunctions.setHandleRequest('start',
-    function(transportId, remoteParams) {
-      natives.StartCastUdpTransport(transportId, remoteParams);
+  apiFunctions.setHandleRequest('setDestination',
+    function(transportId, destination) {
+      natives.SetDestinationCastUdpTransport(transportId, destination);
   });
 });