Data type conversion between extensions API and Cast API

chrome/renderer/extensions/webrtc_native_handler.cc

Index: chrome/renderer/extensions/webrtc_native_handler.cc
diff --git a/chrome/renderer/extensions/webrtc_native_handler.cc b/chrome/renderer/extensions/webrtc_native_handler.cc
index 2695ff7531d22dbe038a85430fec6299ac7ad3df..4343f4f114ff9a089cf18442373fe6c0b114e21d 100644
--- a/chrome/renderer/extensions/webrtc_native_handler.cc
+++ b/chrome/renderer/extensions/webrtc_native_handler.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/renderer/extensions/webrtc_native_handler.h"
 
+#include <functional>
+
 #include "base/logging.h"
 #include "chrome/common/extensions/api/webrtc_cast_send_transport.h"
 #include "chrome/common/extensions/api/webrtc_cast_udp_transport.h"
@@ -17,6 +19,7 @@
 using content::V8ValueConverter;
 
 // Extension types.
+using extensions::api::webrtc_cast_send_transport::CodecSpecificParams;
 using extensions::api::webrtc_cast_send_transport::RtpCaps;
 using extensions::api::webrtc_cast_send_transport::RtpParams;
 using extensions::api::webrtc_cast_send_transport::RtpPayloadParams;
@@ -37,24 +40,150 @@ const char kUnableToConvertParams[] = "Unable to convert params";
 
 // These helper methods are used to convert between Extension API
 // types and Cast types.
+bool ToCastCodecSpecificParams(const CodecSpecificParams& ext_params,
+                               CastCodecSpecificParams* cast_params) {
+  cast_params->key = ext_params.key;
+  cast_params->value = ext_params.value;
+  return true;

[scherkus (not reviewing), 2013/11/01 00:26:23]

this is silly

[Alpha Left Google, 2013/11/01 00:39:20]

Yeah returning a boolean is probably not useful here.

+}
+
+bool FromCastCodecSpecificParams(const CastCodecSpecificParams& cast_params,
+                                 CodecSpecificParams* ext_params) {
+  ext_params->key = cast_params.key;
+  ext_params->value = cast_params.value;
+  return true;

[scherkus (not reviewing), 2013/11/01 00:26:23]

ditto

[Alpha Left Google, 2013/11/01 00:39:20]

Done.

+}
+
+bool ToCastRtpPayloadParams(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->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;
+  for (size_t i = 0; i < ext_params.codec_specific_params.size(); ++i) {
+    CastCodecSpecificParams cast_codec_params;
+    if (!ToCastCodecSpecificParams(*ext_params.codec_specific_params[i],
+                                  &cast_codec_params)) {

[scherkus (not reviewing), 2013/11/01 00:26:23]

fix indent

[Alpha Left Google, 2013/11/01 00:39:20]

Done.

+      return false;
+    }
+    cast_params->codec_specific_params.push_back(cast_codec_params);
+  }
+  return true;

[scherkus (not reviewing), 2013/11/01 00:26:23]

this function always returns true

please s/bool/void/g for these functions and simplify all the code

[Alpha Left Google, 2013/11/01 00:39:20]

Done.

+}
+
+bool 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);
+    *ext_params->ssrc = cast_params.ssrc;
+  }
+  if (cast_params.clock_rate) {
+    ext_params->clock_rate.reset(new int);
+    *ext_params->clock_rate = cast_params.clock_rate;
+  }
+  if (cast_params.min_bitrate) {
+    ext_params->min_bitrate.reset(new int);
+    *ext_params->min_bitrate = cast_params.min_bitrate;
+  }
+  if (cast_params.max_bitrate) {
+    ext_params->max_bitrate.reset(new int);
+    *ext_params->max_bitrate = cast_params.max_bitrate;
+  }
+  if (cast_params.channels) {
+    ext_params->channels.reset(new int);
+    *ext_params->channels = cast_params.channels;
+  }
+  if (cast_params.width) {
+    ext_params->width.reset(new int);
+    *ext_params->width = cast_params.width;
+  }
+  if (cast_params.height) {
+    ext_params->height.reset(new int);
+    *ext_params->height = cast_params.height;
+  }
+  for (size_t i = 0; i < cast_params.codec_specific_params.size(); ++i) {
+    linked_ptr<CodecSpecificParams> ext_codec_params(
+        new CodecSpecificParams());
+    if (!FromCastCodecSpecificParams(cast_params.codec_specific_params[i],
+                                     ext_codec_params.get())) {
+      return false;
+    }
+    ext_params->codec_specific_params.push_back(ext_codec_params);
+  }
+  return true;
+}
+
 bool ToCastRtpCaps(const RtpCaps& ext_caps, CastRtpCaps* cast_caps) {
-  NOTIMPLEMENTED();
+  std::copy(ext_caps.rtcp_features.begin(), ext_caps.rtcp_features.end(),
+            cast_caps->rtcp_features.begin());
+  std::copy(ext_caps.fec_mechanisms.begin(), ext_caps.fec_mechanisms.end(),
+            cast_caps->fec_mechanisms.begin());
+  for (size_t i = 0; i < ext_caps.payloads.size(); ++i) {
+    CastRtpPayloadParams cast_payload_params;
+    if (!ToCastRtpPayloadParams(*ext_caps.payloads[i], &cast_payload_params)) {
+      return false;
+    }
+    cast_caps->payloads.push_back(cast_payload_params);
+  }
   return true;
 }
 
 bool FromCastRtpCaps(const CastRtpCaps& cast_caps, RtpCaps* ext_caps) {
-  NOTIMPLEMENTED();
+  std::copy(cast_caps.rtcp_features.begin(), cast_caps.rtcp_features.end(),
+            ext_caps->rtcp_features.begin());
+  std::copy(cast_caps.fec_mechanisms.begin(), cast_caps.fec_mechanisms.end(),
+            ext_caps->fec_mechanisms.begin());
+  for (size_t i = 0; i < cast_caps.payloads.size(); ++i) {
+    linked_ptr<RtpPayloadParams> ext_payload_params(new RtpPayloadParams());
+    if (!FromCastRtpPayloadParams(cast_caps.payloads[i],
+                                  ext_payload_params.get())) {
+      return false;
+    }
+    ext_caps->payloads.push_back(ext_payload_params);
+  }
   return true;
 }
 
 bool ToCastRtpParams(const RtpParams& ext_params, CastRtpParams* cast_params) {
-  NOTIMPLEMENTED();
+  std::copy(ext_params.rtcp_features.begin(), ext_params.rtcp_features.end(),
+            cast_params->rtcp_features.begin());
+  std::copy(ext_params.fec_mechanisms.begin(), ext_params.fec_mechanisms.end(),
+            cast_params->fec_mechanisms.begin());
+  for (size_t i = 0; i < ext_params.payloads.size(); ++i) {
+    CastRtpPayloadParams cast_payload_params;
+    if (!ToCastRtpPayloadParams(*ext_params.payloads[i],
+                                &cast_payload_params)) {
+      return false;
+    }
+    cast_params->payloads.push_back(cast_payload_params);
+  }
   return true;
 }
 
 bool FromCastRtpParams(const CastRtpParams& cast_params,
                        RtpParams* ext_params) {
-  NOTIMPLEMENTED();
+  std::copy(cast_params.rtcp_features.begin(), cast_params.rtcp_features.end(),
+            ext_params->rtcp_features.begin());
+  std::copy(cast_params.fec_mechanisms.begin(),
+            cast_params.fec_mechanisms.end(),
+            ext_params->fec_mechanisms.begin());
+  for (size_t i = 0; i < cast_params.payloads.size(); ++i) {
+    linked_ptr<RtpPayloadParams> ext_payload_params(new RtpPayloadParams());
+    if (!FromCastRtpPayloadParams(cast_params.payloads[i],
+                                  ext_payload_params.get())) {
+      return false;
+    }
+    ext_params->payloads.push_back(ext_payload_params);
+  }
   return true;
 }