Introduce rtc::PacketTransportInterface and let cricket::TransportChannel inherit.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  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.
  */
 
 #include <algorithm>
 #include <memory>
 
 #include "webrtc/api/fakemetricsobserver.h"
 #include "webrtc/p2p/base/fakeportallocator.h"
+#include "webrtc/p2p/base/packettransportinterface.h"
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 #include "webrtc/p2p/base/testrelayserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/firewallsocketserver.h"
 #include "webrtc/base/gunit.h"
@@ skipping 637 matching lines @@
                      ep2_ch1()->receiving() &&
                      ep2_ch1()->writable(),
                      1000);
 
     EXPECT_TRUE(ep1_ch1()->selected_connection() &&
                 ep2_ch1()->selected_connection());
 
     TestSendRecv();
   }
 
-  void OnReadyToSend(TransportChannel* ch) {
-    GetEndpoint(ch)->ready_to_send_ = true;
+  void OnReadyToSend(rtc::PacketTransportInterface* transport) {
+    GetEndpoint(static_cast<TransportChannel*>(transport))->ready_to_send_ =
+        true;
   }
 
   // We pass the candidates directly to the other side.
   void OnCandidateGathered(TransportChannelImpl* ch, const Candidate& c) {
     if (force_relay_ && c.type() != RELAY_PORT_TYPE)
       return;
 
     if (GetEndpoint(ch)->save_candidates_) {
       GetEndpoint(ch)->saved_candidates_.push_back(
           std::unique_ptr<CandidatesData>(new CandidatesData(ch, c)));
@@ skipping 85 matching lines @@
           return;
         }
         for (Candidate& c : data->candidates) {
           LOG(LS_INFO) << "Removed remote candidate " << c.ToString();
           rch->RemoveRemoteCandidate(c);
         }
         break;
       }
     }
   }
-  void OnReadPacket(TransportChannel* channel,
+
+  void OnReadPacket(rtc::PacketTransportInterface* transport,
                     const char* data,
                     size_t len,
                     const rtc::PacketTime& packet_time,
                     int flags) {
-    std::list<std::string>& packets = GetPacketList(channel);
+    std::list<std::string>& packets =
+        GetPacketList(static_cast<TransportChannel*>(transport));
     packets.push_front(std::string(data, len));
   }
+
   void OnRoleConflict(TransportChannelImpl* channel) {
     GetEndpoint(channel)->OnRoleConflict(true);
     IceRole new_role = GetEndpoint(channel)->ice_role() == ICEROLE_CONTROLLING
                            ? ICEROLE_CONTROLLED
                            : ICEROLE_CONTROLLING;
     channel->SetIceRole(new_role);
   }
 
   int SendData(TransportChannel* channel, const char* data, size_t len) {
     rtc::PacketOptions options;
@@ skipping 2104 matching lines @@
           new StunUInt32Attribute(STUN_ATTR_NOMINATION, nomination));
     }
     msg.SetTransactionID(rtc::CreateRandomString(kStunTransactionIdLength));
     msg.AddMessageIntegrity(conn->local_candidate().password());
     msg.AddFingerprint();
     rtc::ByteBufferWriter buf;
     msg.Write(&buf);
     conn->OnReadPacket(buf.Data(), buf.Length(), rtc::CreatePacketTime(0));
   }
 
-  void OnReadyToSend(TransportChannel* channel) {
+  void OnReadyToSend(rtc::PacketTransportInterface* transport) {
     channel_ready_to_send_ = true;
   }
   void OnChannelStateChanged(TransportChannelImpl* channel) {
     channel_state_ = channel->GetState();
   }
 
   CandidatePairInterface* last_selected_candidate_pair() {
     return last_selected_candidate_pair_;
   }
   int last_sent_packet_id() { return last_sent_packet_id_; }
@@ skipping 1293 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(RELAY_PORT_TYPE, RELAY_PORT_TYPE,
                                TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(LOCAL_PORT_TYPE, RELAY_PORT_TYPE);
 }
 
 }  // namespace cricket {