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 247 matching lines @@
     TransportChannel* channel;
     Candidates candidates;
   };
 
   struct Endpoint {
     Endpoint()
         : role_(ICEROLE_UNKNOWN),
           tiebreaker_(0),
           role_conflict_(false),
           save_candidates_(false) {}
-    bool HasChannel(TransportChannel* ch) {
-      return (ch == cd1_.ch_.get() || ch == cd2_.ch_.get());
+    bool HasTransport(const rtc::PacketTransportInterface* transport) {
+      return (transport == cd1_.ch_.get() || transport == cd2_.ch_.get());
     }
-    ChannelData* GetChannelData(TransportChannel* ch) {
-      if (!HasChannel(ch)) return NULL;
-      if (cd1_.ch_.get() == ch)
+    ChannelData* GetChannelData(rtc::PacketTransportInterface* transport) {
+      if (!HasTransport(transport))
+        return NULL;
+      if (cd1_.ch_.get() == transport)
         return &cd1_;
       else
         return &cd2_;
     }
 
     void SetIceRole(IceRole role) { role_ = role; }
     IceRole ice_role() { return role_; }
     void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
     uint64_t GetIceTiebreaker() { return tiebreaker_; }
     void OnRoleConflict(bool role_conflict) { role_conflict_ = role_conflict; }
@@ skipping 13 matching lines @@
     ChannelData cd1_;
     ChannelData cd2_;
     IceRole role_;
     uint64_t tiebreaker_;
     bool role_conflict_;
     bool save_candidates_;
     std::vector<std::unique_ptr<CandidatesData>> saved_candidates_;
     bool ready_to_send_ = false;
   };
 
-  ChannelData* GetChannelData(TransportChannel* channel) {
-    if (ep1_.HasChannel(channel))
-      return ep1_.GetChannelData(channel);
+  ChannelData* GetChannelData(rtc::PacketTransportInterface* transport) {
+    if (ep1_.HasTransport(transport))
+      return ep1_.GetChannelData(transport);
     else
-      return ep2_.GetChannelData(channel);
+      return ep2_.GetChannelData(transport);
   }
 
   IceParameters IceParamsWithRenomination(const IceParameters& ice,
                                           bool renomination) {
     IceParameters new_ice = ice;
     new_ice.renomination = renomination;
     return new_ice;
   }
 
   void CreateChannels(const IceConfig& ep1_config,
@@ skipping 326 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(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(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;
     return channel->SendPacket(data, len, options, 0);
   }
   bool CheckDataOnChannel(TransportChannel* channel,
                           const char* data,
                           int len) {
     return GetChannelData(channel)->CheckData(data, len);
   }
   static const Candidate* LocalCandidate(P2PTransportChannel* ch) {
     return (ch && ch->selected_connection())
                ? &ch->selected_connection()->local_candidate()
                : NULL;
   }
   static const Candidate* RemoteCandidate(P2PTransportChannel* ch) {
     return (ch && ch->selected_connection())
                ? &ch->selected_connection()->remote_candidate()
                : NULL;
   }
-  Endpoint* GetEndpoint(TransportChannel* ch) {
-    if (ep1_.HasChannel(ch)) {
+  Endpoint* GetEndpoint(rtc::PacketTransportInterface* transport) {
+    if (ep1_.HasTransport(transport)) {
       return &ep1_;
-    } else if (ep2_.HasChannel(ch)) {
+    } else if (ep2_.HasTransport(transport)) {
       return &ep2_;
     } else {
       return NULL;
     }
   }
   P2PTransportChannel* GetRemoteChannel(TransportChannel* ch) {
     if (ch == ep1_ch1())
       return ep2_ch1();
     else if (ch == ep1_ch2())
       return ep2_ch2();
     else if (ch == ep2_ch1())
       return ep1_ch1();
     else if (ch == ep2_ch2())
       return ep1_ch2();
     else
       return NULL;
   }
-  std::list<std::string>& GetPacketList(TransportChannel* ch) {
-    return GetChannelData(ch)->ch_packets_;
+  std::list<std::string>& GetPacketList(
+      rtc::PacketTransportInterface* transport) {
+    return GetChannelData(transport)->ch_packets_;
   }
 
   enum RemoteIceParameterSource { FROM_CANDIDATE, FROM_SETICEPARAMETERS };
 
   // How does the test pass ICE parameters to the P2PTransportChannel?
   // On the candidate itself, or through SetRemoteIceParameters?
   // Goes through the candidate itself by default.
   void set_remote_ice_parameter_source(RemoteIceParameterSource source) {
     remote_ice_parameter_source_ = source;
   }
@@ skipping 2054 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 {