Cast: Add JS API to get raw events logs from cast extension.

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"
@@ skipping 150 matching lines @@
                  base::Unretained(this)));
   RouteFunction("StopCastRtpStream",
       base::Bind(&CastStreamingNativeHandler::StopCastRtpStream,
                  base::Unretained(this)));
   RouteFunction("DestroyCastUdpTransport",
       base::Bind(&CastStreamingNativeHandler::DestroyCastUdpTransport,
                  base::Unretained(this)));
   RouteFunction("SetDestinationCastUdpTransport",
       base::Bind(&CastStreamingNativeHandler::SetDestinationCastUdpTransport,
                  base::Unretained(this)));
+  RouteFunction("StartLogging",
+                base::Bind(&CastStreamingNativeHandler::StartLogging,
+                           base::Unretained(this)));
+  RouteFunction("GetRawEvents",
+                base::Bind(&CastStreamingNativeHandler::GetRawEvents,
+                           base::Unretained(this)));
+  RouteFunction("GetStats",
+                base::Bind(&CastStreamingNativeHandler::GetStats,
+                           base::Unretained(this)));
 }
 
 CastStreamingNativeHandler::~CastStreamingNativeHandler() {
 }
 
 void CastStreamingNativeHandler::CreateCastSession(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(3, args.Length());
   CHECK(args[0]->IsObject());
   CHECK(args[1]->IsObject());
@@ skipping 30 matching lines @@
 
 void CastStreamingNativeHandler::CallCreateCallback(
     scoped_ptr<CastRtpStream> stream1,
     scoped_ptr<CastRtpStream> stream2,
     scoped_ptr<CastUdpTransport> udp_transport) {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
 
   const int stream1_id = last_transport_id_++;
+  stream1->SetStreamId(stream1_id);
   rtp_stream_map_[stream1_id] =
       linked_ptr<CastRtpStream>(stream1.release());
   const int stream2_id = last_transport_id_++;
+  stream2->SetStreamId(stream2_id);
   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(isolate, stream1_id);
   callback_args[1] = v8::Integer::New(isolate, stream2_id);
   callback_args[2] = v8::Integer::New(isolate, udp_id);
@@ skipping 168 matching lines @@
   }
   net::IPAddressNumber ip;
   if (!net::ParseIPLiteralToNumber(destination->address, &ip)) {
     args.GetIsolate()->ThrowException(v8::Exception::TypeError(
         v8::String::NewFromUtf8(args.GetIsolate(), kInvalidDestination)));
     return;
   }
   transport->SetDestination(net::IPEndPoint(ip, destination->port));
 }
 
+void CastStreamingNativeHandler::StartLogging(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK_EQ(1, args.Length());
+  CHECK(args[0]->IsInt32());
+  const int stream_id = args[0]->ToInt32()->Value();
+  CastRtpStream* stream = GetRtpStreamOrThrow(stream_id);
+  if (!stream)
+    return;
+
+  stream->StartLogging();
+}
+
+void CastStreamingNativeHandler::GetRawEvents(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK_EQ(2, args.Length());
+  CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsFunction());
+  const int transport_id = args[0]->ToInt32()->Value();
+  CastRtpStream* transport = GetRtpStreamOrThrow(transport_id);
+  if (!transport)
+    return;
+
+  linked_ptr<extensions::ScopedPersistent<v8::Function> > callback(
+      new extensions::ScopedPersistent<v8::Function>);
+  callback->reset(args[1].As<v8::Function>());
+  get_raw_events_callbacks_.insert(std::make_pair(transport_id, callback));

[Alpha Left Google, 2014/02/24 20:18:56]

This is odd. Why not just pass the callback and v8::function directly to
CallGetRawEventsCallback?

[imcheng, 2014/02/24 21:28:26]

This is similar to CreateCastSession / CallCreateCallback. Per discussion it was
because the function needs to be persistent across different scopes. The args
only return Locals.

+
+  transport->GetRawEvents(
+      base::Bind(&CastStreamingNativeHandler::CallGetRawEventsCallback,
+                 weak_factory_.GetWeakPtr(),
+                 transport_id));
+}
+
+void CastStreamingNativeHandler::GetStats(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK_EQ(2, args.Length());
+  CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsFunction());
+
+  // TODO(imcheng): Implement this.
+}
+
+void CastStreamingNativeHandler::CallGetRawEventsCallback(
+    int transport_id,
+    scoped_ptr<std::string> raw_events) {
+  v8::Isolate* isolate = context()->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Context::Scope context_scope(context()->v8_context());
+
+  RtpStreamCallbackMap::iterator it =
+      get_raw_events_callbacks_.find(transport_id);
+  if (it != get_raw_events_callbacks_.end()) {
+    v8::Handle<v8::Value> callback_args[1];
+    callback_args[0] = v8::String::NewFromUtf8(isolate,
+                                               raw_events->data(),
+                                               v8::String::kNormalString,
+                                               raw_events->size());
+    context()->CallFunction(it->second->NewHandle(isolate), 1, callback_args);
+    get_raw_events_callbacks_.erase(it);
+  }
+}
+
 CastRtpStream* CastStreamingNativeHandler::GetRtpStreamOrThrow(
     int transport_id) const {
   RtpStreamMap::const_iterator iter = rtp_stream_map_.find(
       transport_id);
   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, kRtpStreamNotFound)));
   return NULL;
 }
 
 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