Negotiate the same SRTP crypto suites for every DTLS association formed.

webrtc/p2p/base/dtlstransportchannel.h

 /*
  *  Copyright 2011 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.
  */
 
@@ skipping 68 matching lines @@
 //     downward_, so it immediately calls downward_->Read().
 //
 //   - Data written to DtlsTransport is passed either to downward_ or directly
 //     to ice_transport_, depending on whether DTLS is negotiated and whether
 //     the flags include PF_SRTP_BYPASS
 //
 //   - The SSLStreamAdapter writes to downward_->Write() which translates it
 //     into packet writes on ice_transport_.
 class DtlsTransport : public DtlsTransportInternal {
  public:
-  // The parameters here is:
-  // ice_transport -- the ice transport we are wrapping
-  explicit DtlsTransport(IceTransportInternal* ice_transport);
+  // |ice_transport| is the ICE transport this DTLS transport is wrapping.
+  //
+  // |crypto_options| are the options used for the DTLS handshake. This affects
+  // whether GCM crypto suites are negotiated.
+  explicit DtlsTransport(IceTransportInternal* ice_transport,
+                         const rtc::CryptoOptions& crypto_options);
   ~DtlsTransport() override;
 
   DtlsTransportState dtls_state() const override { return dtls_state_; }
 
   const std::string& transport_name() const override { return transport_name_; }
 
   int component() const override { return component_; }
 
   // Returns false if no local certificate was set, or if the peer doesn't
   // support DTLS.
@@ skipping 13 matching lines @@
                  size_t size,
                  const rtc::PacketOptions& options,
                  int flags) override;
 
   bool GetOption(rtc::Socket::Option opt, int* value) override {
     return ice_transport_->GetOption(opt, value);
   }
 
   virtual bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version);
 
-  // Set up the ciphers to use for DTLS-SRTP. If this method is not called
-  // before DTLS starts, or |ciphers| is empty, SRTP keys won't be negotiated.
-  // This method should be called before SetupDtls.
-  bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) override;
-
   // Find out which DTLS-SRTP cipher was negotiated
   bool GetSrtpCryptoSuite(int* cipher) override;
 
   bool GetSslRole(rtc::SSLRole* role) const override;
   bool SetSslRole(rtc::SSLRole role) override;
 
   // Find out which DTLS cipher was negotiated
   bool GetSslCipherSuite(int* cipher) override;
 
   // Once DTLS has been established, this method retrieves the certificate in
@@ skipping 27 matching lines @@
   bool receiving() const override { return receiving_; }
 
   bool writable() const override { return writable_; }
 
   int GetError() override { return ice_transport_->GetError(); }
 
   int SetOption(rtc::Socket::Option opt, int value) override {
     return ice_transport_->SetOption(opt, value);
   }
 
-  bool SetSrtpCiphers(const std::vector<std::string>& ciphers) override {
-    std::vector<int> crypto_suites;
-    for (const auto cipher : ciphers) {
-      crypto_suites.push_back(rtc::SrtpCryptoSuiteFromName(cipher));
-    }
-    return SetSrtpCryptoSuites(crypto_suites);
-  }
-
   std::string ToString() const {
     const char RECEIVING_ABBREV[2] = {'_', 'R'};
     const char WRITABLE_ABBREV[2] = {'_', 'W'};
     std::stringstream ss;
     ss << "DtlsTransport[" << transport_name_ << "|" << component_ << "|"
        << RECEIVING_ABBREV[receiving()] << WRITABLE_ABBREV[writable()] << "]";
     return ss.str();
   }
 
  private:
@@ skipping 43 matching lines @@
 
   bool receiving_ = false;
   bool writable_ = false;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(DtlsTransport);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_DTLSTRANSPORTCHANNEL_H_