[WIP] bindings: Introduce PropertyBag

Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 73 matching lines @@
 
 } // namespace
 
 RTCConfiguration* RTCPeerConnection::parseConfiguration(const Dictionary& configuration, ExceptionState& exceptionState)
 {
     if (configuration.isUndefinedOrNull())
         return 0;
 
     RTCIceTransports iceTransports = RTCIceTransportsAll;
     String iceTransportsString;
-    if (DictionaryHelper::get(configuration, "iceTransports", iceTransportsString)) {
+    if (configuration.get("iceTransports", iceTransportsString)) {
         if (iceTransportsString == "none") {
             iceTransports = RTCIceTransportsNone;
         } else if (iceTransportsString == "relay") {
             iceTransports = RTCIceTransportsRelay;
         } else if (iceTransportsString != "all") {
             exceptionState.throwTypeError("Malformed RTCIceTransports");
             return 0;
         }
     }
 
     ArrayValue iceServers;
-    bool ok = DictionaryHelper::get(configuration, "iceServers", iceServers);
+    bool ok = configuration.get("iceServers", iceServers);
     if (!ok || iceServers.isUndefinedOrNull()) {
         exceptionState.throwTypeError("Malformed RTCConfiguration");
         return 0;
     }
 
     size_t numberOfServers;
     ok = iceServers.length(numberOfServers);
     if (!ok) {
         exceptionState.throwTypeError("Malformed RTCConfiguration");
         return 0;
     }
 
     RTCConfiguration* rtcConfiguration = RTCConfiguration::create();
     rtcConfiguration->setIceTransports(iceTransports);
 
     for (size_t i = 0; i < numberOfServers; ++i) {
         Dictionary iceServer;
         ok = iceServers.get(i, iceServer);
         if (!ok) {
             exceptionState.throwTypeError("Malformed RTCIceServer");
             return 0;
         }
 
         Vector<String> names;
         iceServer.getOwnPropertyNames(names);
 
         Vector<String> urlStrings;
         if (names.contains("urls")) {
-            if (!DictionaryHelper::get(iceServer, "urls", urlStrings) || !urlStrings.size()) {
+            if (!iceServer.get("urls", urlStrings) || !urlStrings.size()) {
                 String urlString;
-                if (DictionaryHelper::get(iceServer, "urls", urlString)) {
+                if (iceServer.get("urls", urlString)) {
                     urlStrings.append(urlString);
                 } else {
                     exceptionState.throwTypeError("Malformed RTCIceServer");
                     return 0;
                 }
             }
         } else if (names.contains("url")) {
             String urlString;
-            if (DictionaryHelper::get(iceServer, "url", urlString)) {
+            if (iceServer.get("url", urlString)) {
                 urlStrings.append(urlString);
             } else {
                 exceptionState.throwTypeError("Malformed RTCIceServer");
                 return 0;
             }
         } else {
             exceptionState.throwTypeError("Malformed RTCIceServer");
             return 0;
         }
 
         String username, credential;
-        DictionaryHelper::get(iceServer, "username", username);
-        DictionaryHelper::get(iceServer, "credential", credential);
+        iceServer.get("username", username);
+        iceServer.get("credential", credential);
 
         for (Vector<String>::iterator iter = urlStrings.begin(); iter != urlStrings.end(); ++iter) {
             KURL url(KURL(), *iter);
             if (!url.isValid() || !(url.protocolIs("turn") || url.protocolIs("turns") || url.protocolIs("stun"))) {
                 exceptionState.throwTypeError("Malformed URL");
                 return 0;
             }
 
             rtcConfiguration->appendServer(RTCIceServer::create(url, username, credential));
         }
@@ skipping 13 matching lines @@
     // Treat |options| as MediaConstraints if it is empty or has "optional" or "mandatory" properties for compatibility.
     // TODO(jiayl): remove constraints when RTCOfferOptions reaches Stable and client code is ready.
     if (propertyNames.isEmpty() || propertyNames.contains("optional") || propertyNames.contains("mandatory"))
         return 0;
 
     int32_t offerToReceiveVideo = -1;
     int32_t offerToReceiveAudio = -1;
     bool voiceActivityDetection = true;
     bool iceRestart = false;
 
-    if (DictionaryHelper::get(options, "offerToReceiveVideo", offerToReceiveVideo) && offerToReceiveVideo < 0) {
+    if (options.get("offerToReceiveVideo", offerToReceiveVideo) && offerToReceiveVideo < 0) {
         exceptionState.throwTypeError("Invalid offerToReceiveVideo");
         return 0;
     }
 
-    if (DictionaryHelper::get(options, "offerToReceiveAudio", offerToReceiveAudio) && offerToReceiveAudio < 0) {
+    if (options.get("offerToReceiveAudio", offerToReceiveAudio) && offerToReceiveAudio < 0) {
         exceptionState.throwTypeError("Invalid offerToReceiveAudio");
         return 0;
     }
 
-    DictionaryHelper::get(options, "voiceActivityDetection", voiceActivityDetection);
-    DictionaryHelper::get(options, "iceRestart", iceRestart);
+    options.get("voiceActivityDetection", voiceActivityDetection);
+    options.get("iceRestart", iceRestart);
 
     RTCOfferOptions* rtcOfferOptions = RTCOfferOptions::create(offerToReceiveVideo, offerToReceiveAudio, voiceActivityDetection, iceRestart);
     return rtcOfferOptions;
 }
 
 RTCPeerConnection* RTCPeerConnection::create(ExecutionContext* context, const Dictionary& rtcConfiguration, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
 {
     RTCConfiguration* configuration = parseConfiguration(rtcConfiguration, exceptionState);
     if (exceptionState.hadException())
         return 0;
@@ skipping 326 matching lines @@
     // FIXME: Add passing selector as part of the statsRequest.
     m_peerHandler->getStats(statsRequest);
 }
 
 RTCDataChannel* RTCPeerConnection::createDataChannel(String label, const Dictionary& options, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return nullptr;
 
     WebRTCDataChannelInit init;
-    DictionaryHelper::get(options, "ordered", init.ordered);
-    DictionaryHelper::get(options, "negotiated", init.negotiated);
+    options.get("ordered", init.ordered);
+    options.get("negotiated", init.negotiated);
 
     unsigned short value = 0;
-    if (DictionaryHelper::get(options, "id", value))
+    if (options.get("id", value))
         init.id = value;
-    if (DictionaryHelper::get(options, "maxRetransmits", value))
+    if (options.get("maxRetransmits", value))
         init.maxRetransmits = value;
-    if (DictionaryHelper::get(options, "maxRetransmitTime", value))
+    if (options.get("maxRetransmitTime", value))
         init.maxRetransmitTime = value;
 
     String protocolString;
-    DictionaryHelper::get(options, "protocol", protocolString);
+    options.get("protocol", protocolString);
     init.protocol = protocolString;
 
     RTCDataChannel* channel = RTCDataChannel::create(executionContext(), this, m_peerHandler.get(), label, init, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     m_dataChannels.append(channel);
     return channel;
 }
 
 bool RTCPeerConnection::hasLocalStreamWithTrackId(const String& trackId)
@@ skipping 231 matching lines @@
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dataChannels);
 #if ENABLE(OILPAN)
     visitor->trace(m_scheduledEvents);
 #endif
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink