Cast: Let the extension control if DSCP is on or off.

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 <iterator>
 
 #include "base/logging.h"
@@ skipping 166 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("SetOptionsCastUdpTransport",
+      base::Bind(&CastStreamingNativeHandler::SetOptionsCastUdpTransport,
+                 base::Unretained(this)));
   RouteFunction("ToggleLogging",
                 base::Bind(&CastStreamingNativeHandler::ToggleLogging,
                            base::Unretained(this)));
   RouteFunction("GetRawEvents",
                 base::Bind(&CastStreamingNativeHandler::GetRawEvents,
                            base::Unretained(this)));
   RouteFunction("GetStats",
                 base::Bind(&CastStreamingNativeHandler::GetStats,
                            base::Unretained(this)));
 }
@@ skipping 254 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::SetOptionsCastUdpTransport(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK_EQ(2, args.Length());
+  CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsString());
+
+  const int transport_id = args[0]->ToInt32()->Value();
+  CastUdpTransport* transport = GetUdpTransportOrThrow(transport_id);
+  if (!transport)
+    return;
+
+  scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+  std::string option_data;

[Alpha Left Google, 2014/09/09 00:30:45]

If the option is using the type base::DictionaryValue you can use |converter| to
convert it into base::DictionaryValue easily. Note that IPC system supports
base::DictionaryValue already.

[hubbe, 2014/09/09 20:10:01]

Done.

+  if (args[1]->IsNull()) {
+    args.GetIsolate()->ThrowException(v8::Exception::TypeError(
+        v8::String::NewFromUtf8(args.GetIsolate(), kUnableToConvertArgs)));
+  } else {
+    option_data = *v8::String::Utf8Value(args[1]);
+  }
+  transport->SetOptions(option_data);
+}
+
 void CastStreamingNativeHandler::ToggleLogging(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
   CHECK(args[1]->IsBoolean());
 
   const int stream_id = args[0]->ToInt32()->Value();
   CastRtpStream* stream = GetRtpStreamOrThrow(stream_id);
   if (!stream)
     return;
@@ skipping 109 matching lines @@
       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