Create the SrtpTransportInterface.

webrtc/ortc/ortcfactory.cc

 /*
  *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/ortc/ortcfactory.h"
 
 #include <sstream>
+#include <utility>  // For std::move.
 #include <vector>
-#include <utility>  // For std::move.
 
+#include "webrtc/api/mediastreamtrackproxy.h"
 #include "webrtc/api/proxy.h"
-#include "webrtc/api/mediastreamtrackproxy.h"
 #include "webrtc/api/rtcerror.h"
 #include "webrtc/api/videosourceproxy.h"
 #include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/ortc/ortcrtpreceiveradapter.h"
 #include "webrtc/ortc/ortcrtpsenderadapter.h"
 #include "webrtc/ortc/rtpparametersconversion.h"
 #include "webrtc/ortc/rtptransportadapter.h"
 #include "webrtc/ortc/rtptransportcontrolleradapter.h"
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/udptransport.h"
+#include "webrtc/pc/audiotrack.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/localaudiosource.h"
-#include "webrtc/pc/audiotrack.h"
 #include "webrtc/pc/videocapturertracksource.h"
 #include "webrtc/pc/videotrack.h"
 
 namespace {
 
 const int kDefaultRtcpCnameLength = 16;
 
 // Asserts that all of the built-in capabilities can be converted to
 // RtpCapabilities. If they can't, something's wrong (for example, maybe a new
 // feedback mechanism is supported, but an enum value wasn't added to
@@ skipping 22 matching lines @@
 BEGIN_OWNED_PROXY_MAP(OrtcFactory)
 PROXY_SIGNALING_THREAD_DESTRUCTOR()
 PROXY_METHOD0(RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>>,
               CreateRtpTransportController)
 PROXY_METHOD4(RTCErrorOr<std::unique_ptr<RtpTransportInterface>>,
               CreateRtpTransport,
               const RtcpParameters&,
               PacketTransportInterface*,
               PacketTransportInterface*,
               RtpTransportControllerInterface*)
+
+PROXY_METHOD4(RTCErrorOr<std::unique_ptr<SrtpTransportInterface>>,
+              CreateSrtpTransport,
+              const RtcpParameters&,
+              PacketTransportInterface*,
+              PacketTransportInterface*,
+              RtpTransportControllerInterface*)
+
 PROXY_CONSTMETHOD1(RtpCapabilities,
                    GetRtpSenderCapabilities,
                    cricket::MediaType)
 PROXY_METHOD2(RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>>,
               CreateRtpSender,
               rtc::scoped_refptr<MediaStreamTrackInterface>,
               RtpTransportInterface*)
 PROXY_METHOD2(RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>>,
               CreateRtpSender,
               cricket::MediaType,
@@ skipping 152 matching lines @@
     // deleted automatically.
     if (transport_result.ok()) {
       transport_result.value()
           ->GetInternal()
           ->TakeOwnershipOfRtpTransportController(std::move(controller));
     }
     return transport_result;
   }
 }
 
+RTCErrorOr<std::unique_ptr<SrtpTransportInterface>>
+OrtcFactory::CreateSrtpTransport(
+    const RtcpParameters& rtcp_parameters,
+    PacketTransportInterface* rtp,
+    PacketTransportInterface* rtcp,
+    RtpTransportControllerInterface* transport_controller) {
+  RTC_DCHECK_RUN_ON(signaling_thread_);
+  RtcpParameters copied_parameters = rtcp_parameters;
+  if (copied_parameters.cname.empty()) {
+    copied_parameters.cname = default_cname_;
+  }
+  if (transport_controller) {
+    return transport_controller->GetInternal()->CreateProxiedSrtpTransport(
+        copied_parameters, rtp, rtcp);
+  } else {
+    // If |transport_controller| is null, create one automatically, which the
+    // returned SrtpTransport will own.
+    auto controller_result = CreateRtpTransportController();
+    if (!controller_result.ok()) {
+      return controller_result.MoveError();
+    }
+    auto controller = controller_result.MoveValue();
+    auto transport_result =
+        controller->GetInternal()->CreateProxiedSrtpTransport(copied_parameters,
+                                                              rtp, rtcp);
+    // If SrtpTransport was successfully created, transfer ownership of
+    // |rtp_transport_controller|. Otherwise it will go out of scope and be
+    // deleted automatically.
+    if (transport_result.ok()) {
+      transport_result.value()
+          ->GetInternal()
+          ->TakeOwnershipOfRtpTransportController(std::move(controller));
+    }
+    return transport_result;
+  }
+}
+
 RtpCapabilities OrtcFactory::GetRtpSenderCapabilities(
     cricket::MediaType kind) const {
   RTC_DCHECK_RUN_ON(signaling_thread_);
   switch (kind) {
     case cricket::MEDIA_TYPE_AUDIO: {
       cricket::AudioCodecs cricket_codecs;
       cricket::RtpHeaderExtensions cricket_extensions;
       channel_manager_->GetSupportedAudioSendCodecs(&cricket_codecs);
       channel_manager_->GetSupportedAudioRtpHeaderExtensions(
           &cricket_extensions);
@@ skipping 232 matching lines @@
   // OrtcFactory, but aren't yet.
   //
   // Note that |adm_| may be null, in which case the platform-specific default
   // AudioDeviceModule will be used.
   return std::unique_ptr<cricket::MediaEngineInterface>(
       cricket::WebRtcMediaEngineFactory::Create(adm_, audio_decoder_factory_,
                                                 nullptr, nullptr, nullptr));
 }
 
 }  // namespace webrtc