Add support for GCM cipher suites from RFC 7714.

webrtc/p2p/base/faketransportcontroller.h

 /*
  *  Copyright 2009 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 293 matching lines @@
     return true;
   }
 
   void set_ssl_max_protocol_version(rtc::SSLProtocolVersion version) {
     ssl_max_version_ = version;
   }
   rtc::SSLProtocolVersion ssl_max_protocol_version() const {
     return ssl_max_version_;
   }
 
+  void set_enable_gcm_ciphers(bool enable) {
+    enable_gcm_ciphers_ = enable;
+  }
+  bool IsEnableGcmCiphers() const override {
+    return enable_gcm_ciphers_;
+  }
+
  private:
   enum State { STATE_INIT, STATE_CONNECTING, STATE_CONNECTED };
   Transport* transport_;
   FakeTransportChannel* dest_ = nullptr;
   State state_ = STATE_INIT;
   bool async_ = false;
   Candidates remote_candidates_;
   rtc::scoped_refptr<rtc::RTCCertificate> local_cert_;
   rtc::FakeSSLCertificate* remote_cert_ = nullptr;
   bool do_dtls_ = false;
   std::vector<int> srtp_ciphers_;
   int chosen_crypto_suite_ = rtc::SRTP_INVALID_CRYPTO_SUITE;
   int receiving_timeout_ = -1;
   bool gather_continually_ = false;
   IceRole role_ = ICEROLE_UNKNOWN;
   uint64_t tiebreaker_ = 0;
   std::string ice_ufrag_;
   std::string ice_pwd_;
   std::string remote_ice_ufrag_;
   std::string remote_ice_pwd_;
   IceMode remote_ice_mode_ = ICEMODE_FULL;
   rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_10;
+  bool enable_gcm_ciphers_ = false;
   rtc::SSLFingerprint dtls_fingerprint_;
   rtc::SSLRole ssl_role_ = rtc::SSL_CLIENT;
   size_t connection_count_ = 0;
   IceGatheringState gathering_state_ = kIceGatheringNew;
   bool had_connection_ = false;
 };
 
 // Fake transport class, which can be passed to anything that needs a Transport.
 // Can be informed of another FakeTransport via SetDestination (low-tech way
 // of doing candidates)
@@ skipping 52 matching lines @@
   bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version) override {
     ssl_max_version_ = version;
     for (const auto& kv : channels_) {
       kv.second->set_ssl_max_protocol_version(ssl_max_version_);
     }
     return true;
   }
   rtc::SSLProtocolVersion ssl_max_protocol_version() const {
     return ssl_max_version_;
   }
+  bool SetEnableGcmCiphers(bool enable) override {
+    enable_gcm_ciphers_ = enable;
+    for (const auto& kv : channels_) {
+      kv.second->set_enable_gcm_ciphers(enable_gcm_ciphers_);
+    }
+    return true;
+  }
+  bool enable_gcm_ciphers() const {
+    return enable_gcm_ciphers_;
+  }
 
   using Transport::local_description;
   using Transport::remote_description;
 
  protected:
   TransportChannelImpl* CreateTransportChannel(int component) override {
     if (channels_.find(component) != channels_.end()) {
       return nullptr;
     }
     FakeTransportChannel* channel =
         new FakeTransportChannel(this, name(), component);
     channel->set_ssl_max_protocol_version(ssl_max_version_);
+    channel->set_enable_gcm_ciphers(enable_gcm_ciphers_);
     channel->SetAsync(async_);
     SetChannelDestination(component, channel);
     channels_[component] = channel;
     return channel;
   }
 
   void DestroyTransportChannel(TransportChannelImpl* channel) override {
     channels_.erase(channel->component());
     delete channel;
   }
@@ skipping 17 matching lines @@
 
   // Note, this is distinct from the Channel map owned by Transport.
   // This map just tracks the FakeTransportChannels created by this class.
   // It's mainly needed so that we can access a FakeTransportChannel directly,
   // even if wrapped by a DtlsTransportChannelWrapper.
   ChannelMap channels_;
   FakeTransport* dest_ = nullptr;
   bool async_ = false;
   rtc::scoped_refptr<rtc::RTCCertificate> certificate_;
   rtc::SSLProtocolVersion ssl_max_version_ = rtc::SSL_PROTOCOL_DTLS_10;
+  bool enable_gcm_ciphers_ = false;
 };
 
 // Fake TransportController class, which can be passed into a BaseChannel object
 // for test purposes. Can be connected to other FakeTransportControllers via
 // Connect().
 //
 // This fake is unusual in that for the most part, it's implemented with the
 // real TransportController code, but with fake TransportChannels underneath.
 class FakeTransportController : public TransportController {
  public:
@@ skipping 67 matching lines @@
     }
   }
 
  private:
   bool fail_create_channel_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_FAKETRANSPORTCONTROLLER_H_