Renamed dtlstransportchannel.h/.cc/_unittest.cc.

webrtc/p2p/base/dtlstransport.cc

 /*
  *  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.
  */
 
+#include <algorithm>
 #include <memory>
 #include <utility>
 
-#include "webrtc/p2p/base/dtlstransportchannel.h"
+#include "webrtc/p2p/base/dtlstransport.h"
 
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/packettransportinternal.h"
 #include "webrtc/rtc_base/buffer.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/dscp.h"
 #include "webrtc/rtc_base/messagequeue.h"
 #include "webrtc/rtc_base/sslstreamadapter.h"
 #include "webrtc/rtc_base/stream.h"
 #include "webrtc/rtc_base/thread.h"
@@ skipping 30 matching lines @@
   return (len >= kMinRtpPacketLen && (u[0] & 0xC0) == 0x80);
 }
 
 StreamInterfaceChannel::StreamInterfaceChannel(
     IceTransportInternal* ice_transport)
     : ice_transport_(ice_transport),
       state_(rtc::SS_OPEN),
       packets_(kMaxPendingPackets, kMaxDtlsPacketLen) {}
 
 rtc::StreamResult StreamInterfaceChannel::Read(void* buffer,
-                                                     size_t buffer_len,
-                                                     size_t* read,
-                                                     int* error) {
+                                               size_t buffer_len,
+                                               size_t* read,
+                                               int* error) {
   if (state_ == rtc::SS_CLOSED)
     return rtc::SR_EOS;
   if (state_ == rtc::SS_OPENING)
     return rtc::SR_BLOCK;
 
   if (!packets_.ReadFront(buffer, buffer_len, read)) {
     return rtc::SR_BLOCK;
   }
 
   return rtc::SR_SUCCESS;
 }
 
 rtc::StreamResult StreamInterfaceChannel::Write(const void* data,
-                                                      size_t data_len,
-                                                      size_t* written,
-                                                      int* error) {
+                                                size_t data_len,
+                                                size_t* written,
+                                                int* error) {
   // Always succeeds, since this is an unreliable transport anyway.
   // TODO(zhihuang): Should this block if ice_transport_'s temporarily
   // unwritable?
   rtc::PacketOptions packet_options;
   ice_transport_->SendPacket(static_cast<const char*>(data), data_len,
                              packet_options);
   if (written) {
     *written = data_len;
   }
   return rtc::SR_SUCCESS;
@@ skipping 228 matching lines @@
 }
 
 bool DtlsTransport::GetSrtpCryptoSuite(int* cipher) {
   if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
     return false;
   }
 
   return dtls_->GetDtlsSrtpCryptoSuite(cipher);
 }
 
-
 // Called from upper layers to send a media packet.
 int DtlsTransport::SendPacket(const char* data,
                               size_t size,
                               const rtc::PacketOptions& options,
                               int flags) {
   if (!dtls_active_) {
     // Not doing DTLS.
     return ice_transport_->SendPacket(data, size, options);
   }
 
@@ skipping 321 matching lines @@
   SignalDtlsHandshakeError(error);
 }
 
 void DtlsTransport::ConfigureHandshakeTimeout() {
   RTC_DCHECK(dtls_);
   rtc::Optional<int> rtt = ice_transport_->GetRttEstimate();
   if (rtt) {
     // Limit the timeout to a reasonable range in case the ICE RTT takes
     // extreme values.
     int initial_timeout = std::max(kMinHandshakeTimeout,
-                                   std::min(kMaxHandshakeTimeout,
-                                            2 * (*rtt)));
+                                   std::min(kMaxHandshakeTimeout, 2 * (*rtt)));
     LOG_J(LS_INFO, this) << "configuring DTLS handshake timeout "
                          << initial_timeout << " based on ICE RTT " << *rtt;
 
     dtls_->SetInitialRetransmissionTimeout(initial_timeout);
   } else {
     LOG_J(LS_INFO, this)
         << "no RTT estimate - using default DTLS handshake timeout";
   }
 }
 
-
 }  // namespace cricket