Cast Extensions API: Major namespace and object renaming

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/webrtc_native_handler.h"
+#include "chrome/renderer/extensions/cast_streaming_native_handler.h"
 
 #include <functional>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
-#include "chrome/common/extensions/api/webrtc_cast_send_transport.h"
-#include "chrome/common/extensions/api/webrtc_cast_udp_transport.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_send_transport.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::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;
-using extensions::api::webrtc_cast_udp_transport::UdpParams;
+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 kSendTransportNotFound[] = "The send transport cannot be found";
+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 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) {
@@ skipping 70 matching lines @@
             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);
     cast_params->payloads.push_back(cast_payload_params);
   }
 }
 
 }  // namespace
 
-WebRtcNativeHandler::WebRtcNativeHandler(ChromeV8Context* context)
+CastStreamingNativeHandler::CastStreamingNativeHandler(ChromeV8Context* context)
     : ObjectBackedNativeHandler(context),
       last_transport_id_(0),
       weak_factory_(this) {
   RouteFunction("CreateSession",
-      base::Bind(&WebRtcNativeHandler::CreateCastSession,
+      base::Bind(&CastStreamingNativeHandler::CreateCastSession,
                  base::Unretained(this)));
-  RouteFunction("DestroyCastSendTransport",
-      base::Bind(&WebRtcNativeHandler::DestroyCastSendTransport,
+  RouteFunction("DestroyCastRtpStream",
+      base::Bind(&CastStreamingNativeHandler::DestroyCastRtpStream,
                  base::Unretained(this)));
-  RouteFunction("GetCapsCastSendTransport",
-      base::Bind(&WebRtcNativeHandler::GetCapsCastSendTransport,
+  RouteFunction("GetCapsCastRtpStream",
+      base::Bind(&CastStreamingNativeHandler::GetCapsCastRtpStream,
                  base::Unretained(this)));
-  RouteFunction("StartCastSendTransport",
-      base::Bind(&WebRtcNativeHandler::StartCastSendTransport,
+  RouteFunction("StartCastRtpStream",
+      base::Bind(&CastStreamingNativeHandler::StartCastRtpStream,
                  base::Unretained(this)));
-  RouteFunction("StopCastSendTransport",
-      base::Bind(&WebRtcNativeHandler::StopCastSendTransport,
+  RouteFunction("StopCastRtpStream",
+      base::Bind(&CastStreamingNativeHandler::StopCastRtpStream,
                  base::Unretained(this)));
   RouteFunction("DestroyCastUdpTransport",
-      base::Bind(&WebRtcNativeHandler::DestroyCastUdpTransport,
+      base::Bind(&CastStreamingNativeHandler::DestroyCastUdpTransport,
                  base::Unretained(this)));
   RouteFunction("StartCastUdpTransport",
-      base::Bind(&WebRtcNativeHandler::StartCastUdpTransport,
+      base::Bind(&CastStreamingNativeHandler::StartCastUdpTransport,
                  base::Unretained(this)));
 }
 
-WebRtcNativeHandler::~WebRtcNativeHandler() {
+CastStreamingNativeHandler::~CastStreamingNativeHandler() {
 }
 
-void WebRtcNativeHandler::CreateCastSession(
+void CastStreamingNativeHandler::CreateCastSession(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(3, args.Length());
   CHECK(args[0]->IsObject());
   CHECK(args[1]->IsObject());
   CHECK(args[2]->IsFunction());
 
   blink::WebDOMMediaStreamTrack track1 =
       blink::WebDOMMediaStreamTrack::fromV8Value(args[0]);
   if (track1.isNull())
     return;
   blink::WebDOMMediaStreamTrack track2 =
       blink::WebDOMMediaStreamTrack::fromV8Value(args[1]);
   if (track2.isNull())
     return;
 
   scoped_refptr<CastSession> session(new CastSession());
-  scoped_ptr<CastSendTransport> stream1(
-      new CastSendTransport(track1.component(), session));
-  scoped_ptr<CastSendTransport> stream2(
-      new CastSendTransport(track2.component(), session));
+  scoped_ptr<CastRtpStream> stream1(
+      new CastRtpStream(track1.component(), session));
+  scoped_ptr<CastRtpStream> stream2(
+      new CastRtpStream(track2.component(), session));
   scoped_ptr<CastUdpTransport> udp_transport(
       new CastUdpTransport(session));
 
   create_callback_.reset(args[2].As<v8::Function>());
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(
-          &WebRtcNativeHandler::CallCreateCallback,
+          &CastStreamingNativeHandler::CallCreateCallback,
           weak_factory_.GetWeakPtr(),
           base::Passed(&stream1),
           base::Passed(&stream2),
           base::Passed(&udp_transport)));
 }
 
-void WebRtcNativeHandler::CallCreateCallback(
-    scoped_ptr<CastSendTransport> stream1,
-    scoped_ptr<CastSendTransport> stream2,
+void CastStreamingNativeHandler::CallCreateCallback(
+    scoped_ptr<CastRtpStream> stream1,
+    scoped_ptr<CastRtpStream> stream2,
     scoped_ptr<CastUdpTransport> udp_transport) {
   v8::HandleScope handle_scope(context()->isolate());
   v8::Context::Scope context_scope(context()->v8_context());
 
   const int stream1_id = last_transport_id_++;
-  send_transport_map_[stream1_id] =
-      linked_ptr<CastSendTransport>(stream1.release());
+  rtp_stream_map_[stream1_id] =
+      linked_ptr<CastRtpStream>(stream1.release());
   const int stream2_id = last_transport_id_++;
-  send_transport_map_[stream2_id] =
-      linked_ptr<CastSendTransport>(stream2.release());
+  rtp_stream_map_[stream2_id] =
+      linked_ptr<CastRtpStream>(stream2.release());
   const int udp_id = last_transport_id_++;
   udp_transport_map_[udp_id] =
       linked_ptr<CastUdpTransport>(udp_transport.release());
 
   v8::Handle<v8::Value> callback_args[3];
   callback_args[0] = v8::Integer::New(stream1_id);
   callback_args[1] = v8::Integer::New(stream2_id);
   callback_args[2] = v8::Integer::New(udp_id);
   context()->CallFunction(create_callback_.NewHandle(context()->isolate()),
                           3, callback_args);
   create_callback_.reset();
 }
 
-void WebRtcNativeHandler::DestroyCastSendTransport(
+void CastStreamingNativeHandler::DestroyCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
   const int transport_id = args[0]->ToInt32()->Value();
-  if (!GetSendTransportOrThrow(transport_id))
+  if (!GetRtpStreamOrThrow(transport_id))
     return;
-  send_transport_map_.erase(transport_id);
+  rtp_stream_map_.erase(transport_id);
 }
 
-void WebRtcNativeHandler::GetCapsCastSendTransport(
+void CastStreamingNativeHandler::GetCapsCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
   const int transport_id = args[0]->ToInt32()->Value();
-  CastSendTransport* transport = GetSendTransportOrThrow(transport_id);
+  CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   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()));
 }
 
-void WebRtcNativeHandler::StartCastSendTransport(
+void CastStreamingNativeHandler::StartCastRtpStream(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsObject());
 
   const int transport_id = args[0]->ToInt32()->Value();
-  CastSendTransport* transport = GetSendTransportOrThrow(transport_id);
+  CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   scoped_ptr<Value> params_value(
       converter->FromV8Value(args[1], context()->v8_context()));
   if (!params_value) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertParams)));
     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);
   transport->Start(cast_params);
 }
 
-void WebRtcNativeHandler::StopCastSendTransport(
+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();
-  CastSendTransport* transport = GetSendTransportOrThrow(transport_id);
+  CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
   if (!transport)
     return;
   transport->Stop();
 }
 
-void WebRtcNativeHandler::DestroyCastUdpTransport(
+void CastStreamingNativeHandler::DestroyCastUdpTransport(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   CHECK(args[0]->IsInt32());
 
   const int transport_id = args[0]->ToInt32()->Value();
   if (!GetUdpTransportOrThrow(transport_id))
     return;
   udp_transport_map_.erase(transport_id);
 }
 
-void WebRtcNativeHandler::StartCastUdpTransport(
+void CastStreamingNativeHandler::StartCastUdpTransport(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsObject());
 
   const int transport_id = args[0]->ToInt32()->Value();
   CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
   if (!transport)
     return;
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
   scoped_ptr<Value> udp_params_value(
       converter->FromV8Value(args[1], context()->v8_context()));
   if (!udp_params_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) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidUdpParams)));
     return;
   }
   transport->Start(net::HostPortPair(udp_params->address, udp_params->port));
 }
 
-CastSendTransport* WebRtcNativeHandler::GetSendTransportOrThrow(
+CastRtpStream* CastStreamingNativeHandler::GetRtpStreamOrThrow(
     int transport_id) const {
-  SendTransportMap::const_iterator iter = send_transport_map_.find(
+  RtpStreamMap::const_iterator iter = rtp_stream_map_.find(
       transport_id);
-  if (iter != send_transport_map_.end())
+  if (iter != rtp_stream_map_.end())
     return iter->second.get();
   v8::Isolate* isolate = context()->v8_context()->GetIsolate();
-  isolate->ThrowException(v8::Exception::RangeError(
-      v8::String::NewFromUtf8(isolate, kSendTransportNotFound)));
+  isolate->ThrowException(v8::Exception::RangeError(v8::String::NewFromUtf8(
+      isolate, kRtpStreamNotFound)));
   return NULL;
 }
 
-CastUdpTransport* WebRtcNativeHandler::GetUdpTransportOrThrow(
+CastUdpTransport* CastStreamingNativeHandler::GetUdpTransportOrThrow(
     int transport_id) const {
   UdpTransportMap::const_iterator iter = udp_transport_map_.find(
       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