Converts RTCOfferOptions to constriants in the glue code for createOffer.

content/renderer/media/rtc_peer_connection_handler.cc

 // Copyright (c) 2012 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 "content/renderer/media/rtc_peer_connection_handler.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 16 matching lines @@
 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebRTCConfiguration.h"
 #include "third_party/WebKit/public/platform/WebRTCDataChannelInit.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
+#include "third_party/WebKit/public/platform/WebRTCOfferOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescription.h"
 #include "third_party/WebKit/public/platform/WebRTCSessionDescriptionRequest.h"
 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 
 namespace content {
 
 // Converter functions from libjingle types to WebKit types.
 blink::WebRTCPeerConnectionHandlerClient::ICEGatheringState
 GetWebKitIceGatheringState(
@@ skipping 75 matching lines @@
     return description;
   }
 
   description.initialize(base::UTF8ToUTF16(native_desc->type()),
                          base::UTF8ToUTF16(sdp));
   return description;
 }
 
 // Converter functions from WebKit types to libjingle types.
 
-static void GetNativeIceServers(
+static void GetNativeRtcConfiguration(
     const blink::WebRTCConfiguration& server_configuration,
-    webrtc::PeerConnectionInterface::IceServers* servers) {
-  if (server_configuration.isNull() || !servers)
+    webrtc::PeerConnectionInterface::RTCConfiguration* config) {
+  if (server_configuration.isNull() || !config)
     return;
   for (size_t i = 0; i < server_configuration.numberOfServers(); ++i) {
     webrtc::PeerConnectionInterface::IceServer server;
     const blink::WebRTCICEServer& webkit_server =
         server_configuration.server(i);
     server.username = base::UTF16ToUTF8(webkit_server.username());
     server.password = base::UTF16ToUTF8(webkit_server.credential());
     server.uri = webkit_server.uri().spec();
-    servers->push_back(server);
+    config->servers.push_back(server);
+  }
+
+  switch (server_configuration.iceTransports()) {
+  case blink::WebRTCIceTransportsNone:
+    config->type = webrtc::PeerConnectionInterface::kNone;
+    break;
+  case blink::WebRTCIceTransportsRelay:
+    config->type = webrtc::PeerConnectionInterface::kRelay;
+    break;
+  case blink::WebRTCIceTransportsAll:
+    config->type = webrtc::PeerConnectionInterface::kAll;
+    break;
+  default:
+    NOTREACHED();
   }
 }
 
 class SessionDescriptionRequestTracker {
  public:
   SessionDescriptionRequestTracker(RTCPeerConnectionHandler* handler,
                                    PeerConnectionTracker::Action action)
       : handler_(handler), action_(action) {}
 
   void TrackOnSuccess(const webrtc::SessionDescriptionInterface* desc) {
@@ skipping 239 matching lines @@
   std::set<RTCPeerConnectionHandler*> handlers(
       g_peer_connection_handlers.Get().begin(),
       g_peer_connection_handlers.Get().end());
   for (std::set<RTCPeerConnectionHandler*>::iterator handler = handlers.begin();
        handler != handlers.end();
        ++handler) {
     (*handler)->client_->releasePeerConnectionHandler();
   }
 }
 
+void RTCPeerConnectionHandler::ConvertOfferOptionsToConstraints(
+    const blink::WebRTCOfferOptions& options,
+    RTCMediaConstraints* output) {
+  output->AddMandatory(
+      webrtc::MediaConstraintsInterface::kOfferToReceiveAudio,
+      options.offerToReceiveAudio() > 0 ? "true" : "false",
+      true);
+
+  output->AddMandatory(
+      webrtc::MediaConstraintsInterface::kOfferToReceiveVideo,
+      options.offerToReceiveVideo() > 0 ? "true" : "false",
+      true);
+
+  if (!options.voiceActivityDetection()) {
+    output->AddMandatory(
+        webrtc::MediaConstraintsInterface::kVoiceActivityDetection,
+        "false",
+        true);
+  }
+
+  if (options.iceRestart()) {
+    output->AddMandatory(
+        webrtc::MediaConstraintsInterface::kIceRestart, "true", true);
+  }
+}
+
 void RTCPeerConnectionHandler::associateWithFrame(blink::WebFrame* frame) {
   DCHECK(frame);
   frame_ = frame;
 }
 
 bool RTCPeerConnectionHandler::initialize(
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options) {
   DCHECK(frame_);
 
   peer_connection_tracker_ =
       RenderThreadImpl::current()->peer_connection_tracker();
 
-  webrtc::PeerConnectionInterface::IceServers servers;
-  GetNativeIceServers(server_configuration, &servers);
+  webrtc::PeerConnectionInterface::RTCConfiguration config;
+  GetNativeRtcConfiguration(server_configuration, &config);
 
   RTCMediaConstraints constraints(options);
 
   native_peer_connection_ =
       dependency_factory_->CreatePeerConnection(
-          servers, &constraints, frame_, this);
+          config, &constraints, frame_, this);
+
   if (!native_peer_connection_.get()) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
   if (peer_connection_tracker_)
     peer_connection_tracker_->RegisterPeerConnection(
-        this, servers, constraints, frame_);
+        this, config, constraints, frame_);
 
   uma_observer_ = new talk_base::RefCountedObject<PeerConnectionUMAObserver>();
   native_peer_connection_->RegisterUMAObserver(uma_observer_.get());
   return true;
 }
 
 bool RTCPeerConnectionHandler::InitializeForTest(
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options,
     PeerConnectionTracker* peer_connection_tracker) {
-  webrtc::PeerConnectionInterface::IceServers servers;
-  GetNativeIceServers(server_configuration, &servers);
+  webrtc::PeerConnectionInterface::RTCConfiguration config;
+  GetNativeRtcConfiguration(server_configuration, &config);
 
   RTCMediaConstraints constraints(options);
   native_peer_connection_ =
       dependency_factory_->CreatePeerConnection(
-          servers, &constraints, NULL, this);
+          config, &constraints, NULL, this);
   if (!native_peer_connection_.get()) {
     LOG(ERROR) << "Failed to initialize native PeerConnection.";
     return false;
   }
   peer_connection_tracker_ = peer_connection_tracker;
   return true;
 }
 
 void RTCPeerConnectionHandler::createOffer(
     const blink::WebRTCSessionDescriptionRequest& request,
     const blink::WebMediaConstraints& options) {
   scoped_refptr<CreateSessionDescriptionRequest> description_request(
       new talk_base::RefCountedObject<CreateSessionDescriptionRequest>(
           request, this, PeerConnectionTracker::ACTION_CREATE_OFFER));
   RTCMediaConstraints constraints(options);
   native_peer_connection_->CreateOffer(description_request.get(), &constraints);
 
   if (peer_connection_tracker_)
     peer_connection_tracker_->TrackCreateOffer(this, constraints);
 }
 
+void RTCPeerConnectionHandler::createOffer(
+    const blink::WebRTCSessionDescriptionRequest& request,
+    const blink::WebRTCOfferOptions& options) {
+  scoped_refptr<CreateSessionDescriptionRequest> description_request(
+      new talk_base::RefCountedObject<CreateSessionDescriptionRequest>(
+          request, this, PeerConnectionTracker::ACTION_CREATE_OFFER));
+
+  RTCMediaConstraints constraints;
+  ConvertOfferOptionsToConstraints(options, &constraints);
+  native_peer_connection_->CreateOffer(description_request.get(), &constraints);
+
+  if (peer_connection_tracker_)
+    peer_connection_tracker_->TrackCreateOffer(this, constraints);
+}
+
 void RTCPeerConnectionHandler::createAnswer(
     const blink::WebRTCSessionDescriptionRequest& request,
     const blink::WebMediaConstraints& options) {
   scoped_refptr<CreateSessionDescriptionRequest> description_request(
       new talk_base::RefCountedObject<CreateSessionDescriptionRequest>(
           request, this, PeerConnectionTracker::ACTION_CREATE_ANSWER));
   RTCMediaConstraints constraints(options);
   native_peer_connection_->CreateAnswer(description_request.get(),
                                         &constraints);
 
@@ skipping 65 matching lines @@
   const webrtc::SessionDescriptionInterface* native_desc =
       native_peer_connection_->remote_description();
   blink::WebRTCSessionDescription description =
       CreateWebKitSessionDescription(native_desc);
   return description;
 }
 
 bool RTCPeerConnectionHandler::updateICE(
     const blink::WebRTCConfiguration& server_configuration,
     const blink::WebMediaConstraints& options) {
-  webrtc::PeerConnectionInterface::IceServers servers;
-  GetNativeIceServers(server_configuration, &servers);
+  webrtc::PeerConnectionInterface::RTCConfiguration config;
+  GetNativeRtcConfiguration(server_configuration, &config);
   RTCMediaConstraints constraints(options);
 
   if (peer_connection_tracker_)
-    peer_connection_tracker_->TrackUpdateIce(this, servers, constraints);
+    peer_connection_tracker_->TrackUpdateIce(this, config, constraints);
 
-  return native_peer_connection_->UpdateIce(servers,
+  return native_peer_connection_->UpdateIce(config.servers,
                                             &constraints);
 }
 
 bool RTCPeerConnectionHandler::addICECandidate(
   const blink::WebRTCVoidRequest& request,
   const blink::WebRTCICECandidate& candidate) {
   // Libjingle currently does not accept callbacks for addICECandidate.
   // For that reason we are going to call callbacks from here.
   bool result = addICECandidate(candidate);
   base::MessageLoop::current()->PostTask(
@@ skipping 356 matching lines @@
   webrtc::SessionDescriptionInterface* native_desc =
       dependency_factory_->CreateSessionDescription(type, sdp, error);
 
   LOG_IF(ERROR, !native_desc) << "Failed to create native session description."
                               << " Type: " << type << " SDP: " << sdp;
 
   return native_desc;
 }
 
 }  // namespace content