generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert "Add adapter_type into Candidate object."

Browse Source 
This reverts commit aaf02cc2d4f696345ce0e6d5715f2cfa22aea689.

BUG=
TBR=juberti@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/35539004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@7908 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
guoweis@webrtc.org 2014-12-16 05:28:10 +00:00
parent d021bbbc9e
commit 55360ae402
15 changed files with 107 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
talk/app/webrtc/jsepsessiondescription_unittest.cc
View File

@ -101,7 +101,8 @@ class JsepSessionDescriptionTest : public testing::Test {
int port = 1234;
rtc::SocketAddress address("127.0.0.1", port++);
cricket::Candidate candidate("rtp", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", address, 1, "", "", "local", 0, "1");
"udp", address, 1, "",
"", "local", "eth0", 0, "1");
candidate_ = candidate;
const std::string session_id =
rtc::ToString(rtc::CreateRandomId64());

40
talk/app/webrtc/statscollector.cc
View File

@ -619,37 +619,6 @@ std::string StatsCollector::AddCertificateReports(
return AddOneCertificateReport(cert, issuer_id);
}
std::string StatsCollector::AddCandidateReport(
const cricket::Candidate& candidate,
const std::string& report_type) {
std::ostringstream ost;
ost << "Cand-" << candidate.id();
StatsReport* report = reports_.Find(ost.str());
if (!report) {
report = reports_.InsertNew(ost.str());
DCHECK(StatsReport::kStatsReportTypeIceLocalCandidate == report_type ||
StatsReport::kStatsReportTypeIceRemoteCandidate == report_type);
report->type = report_type;
if (report_type == StatsReport::kStatsReportTypeIceLocalCandidate) {
report->AddValue(StatsReport::kStatsValueNameCandidateNetworkType,
rtc::AdapterTypeToStatsType(candidate.network_type()));
}
report->timestamp = stats_gathering_started_;
report->AddValue(StatsReport::kStatsValueNameCandidateIPAddress,
candidate.address().ipaddr().ToString());
report->AddValue(StatsReport::kStatsValueNameCandidatePortNumber,
candidate.address().PortAsString());
report->AddValue(StatsReport::kStatsValueNameCandidatePriority,
candidate.priority());
report->AddValue(StatsReport::kStatsValueNameCandidateType,
cricket::IceCandidateTypeToStatsType(candidate.type()));
report->AddValue(StatsReport::kStatsValueNameCandidateTransportType,
candidate.protocol());
}
return ost.str();
}
void StatsCollector::ExtractSessionInfo() {
ASSERT(session_->signaling_thread()->IsCurrent());
// Extract information from the base session.
@ -742,15 +711,6 @@ void StatsCollector::ExtractSessionInfo() {
info.readable);
report->AddBoolean(StatsReport::kStatsValueNameActiveConnection,
info.best_connection);
report->AddValue(StatsReport::kStatsValueNameLocalCandidateId,
AddCandidateReport(
info.local_candidate,
StatsReport::kStatsReportTypeIceLocalCandidate));
report->AddValue(
StatsReport::kStatsValueNameRemoteCandidateId,
AddCandidateReport(
info.remote_candidate,
StatsReport::kStatsReportTypeIceRemoteCandidate));
report->AddValue(StatsReport::kStatsValueNameLocalAddress,
info.local_candidate.address().ToString());
report->AddValue(StatsReport::kStatsValueNameRemoteAddress,

7
talk/app/webrtc/statscollector.h
View File

@ -93,19 +93,12 @@ class StatsCollector {
void ClearUpdateStatsCacheForTest();
private:
friend class StatsCollectorTest;
bool CopySelectedReports(const std::string& selector, StatsReports* reports);
// Helper method for AddCertificateReports.
std::string AddOneCertificateReport(
const rtc::SSLCertificate* cert, const std::string& issuer_id);
// Helper method for creating IceCandidate report. |is_local| indicates
// whether this candidate is local or remote.
std::string AddCandidateReport(const cricket::Candidate& candidate,
const std::string& report_type);
// Adds a report for this certificate and every certificate in its chain, and
// returns the leaf certificate's report's ID.
std::string AddCertificateReports(const rtc::SSLCertificate* cert);

102
talk/app/webrtc/statscollector_unittest.cc
View File

@ -42,7 +42,6 @@
#include "webrtc/base/base64.h"
#include "webrtc/base/fakesslidentity.h"
#include "webrtc/base/gunit.h"
#include "webrtc/base/network.h"
using cricket::StatsOptions;
using testing::_;
@ -62,7 +61,7 @@ class FakeDeviceManager;
} // namespace cricket
namespace webrtc {
namespace {
// Error return values
const char kNotFound[] = "NOT FOUND";
@ -502,12 +501,6 @@ class StatsCollectorTest : public testing::Test {
.WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
}
std::string AddCandidateReport(StatsCollector* collector,
const cricket::Candidate& candidate,
const std::string& report_type) {
return collector->AddCandidateReport(candidate, report_type);
}
void SetupAndVerifyAudioTrackStats(
FakeAudioTrack* audio_track,
webrtc::MediaStream* stream,
@ -1023,97 +1016,6 @@ TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
EXPECT_EQ(kRemoteTrackId, track_id);
}
// This test verifies the Ice Candidate report should contain the correct
// information from local/remote candidates.
TEST_F(StatsCollectorTest, IceCandidateReport) {
webrtc::StatsCollector stats(&session_); // Implementation under test.
StatsReports reports; // returned values.
const int local_port = 2000;
const char local_ip[] = "192.168.0.1";
const int remote_port = 2001;
const char remote_ip[] = "192.168.0.2";
rtc::SocketAddress local_address(local_ip, local_port);
rtc::SocketAddress remote_address(remote_ip, remote_port);
rtc::AdapterType network_type = rtc::ADAPTER_TYPE_ETHERNET;
uint32 priority = 1000;
cricket::Candidate c;
const std::string& local_id = rtc::CreateRandomString(8);
c.set_id(local_id);
c.set_type(cricket::LOCAL_PORT_TYPE);
c.set_protocol(cricket::UDP_PROTOCOL_NAME);
c.set_address(local_address);
c.set_priority(priority);
c.set_network_type(network_type);
std::string report_id = AddCandidateReport(
&stats, c, StatsReport::kStatsReportTypeIceLocalCandidate);
EXPECT_EQ("Cand-" + local_id, report_id);
const std::string& remote_id = rtc::CreateRandomString(8);
c.set_id(remote_id);
c.set_type(cricket::PRFLX_PORT_TYPE);
c.set_address(remote_address);
report_id = AddCandidateReport(
&stats, c, StatsReport::kStatsReportTypeIceRemoteCandidate);
EXPECT_EQ("Cand-" + remote_id, report_id);
stats.GetStats(NULL, &reports);
// Verify the local candidate report is populated correctly.
EXPECT_EQ(
local_ip,
ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
StatsReport::kStatsValueNameCandidateIPAddress));
EXPECT_EQ(
rtc::ToString<int>(local_port),
ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
StatsReport::kStatsValueNameCandidatePortNumber));
EXPECT_EQ(
cricket::UDP_PROTOCOL_NAME,
ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
StatsReport::kStatsValueNameCandidateTransportType));
EXPECT_EQ(
rtc::ToString<int>(priority),
ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
StatsReport::kStatsValueNameCandidatePriority));
EXPECT_EQ(
cricket::IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE),
ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
StatsReport::kStatsValueNameCandidateType));
EXPECT_EQ(
rtc::AdapterTypeToStatsType(network_type),
ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
StatsReport::kStatsValueNameCandidateNetworkType));
// Verify the remote candidate report is populated correctly.
EXPECT_EQ(remote_ip,
ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
reports,
StatsReport::kStatsValueNameCandidateIPAddress));
EXPECT_EQ(rtc::ToString<int>(remote_port),
ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
reports,
StatsReport::kStatsValueNameCandidatePortNumber));
EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
ExtractStatsValue(
StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
StatsReport::kStatsValueNameCandidateTransportType));
EXPECT_EQ(rtc::ToString<int>(priority),
ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
reports,
StatsReport::kStatsValueNameCandidatePriority));
EXPECT_EQ(
cricket::IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE),
ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
reports, StatsReport::kStatsValueNameCandidateType));
EXPECT_EQ(kNotFound,
ExtractStatsValue(
StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
StatsReport::kStatsValueNameCandidateNetworkType));
}
// This test verifies that all chained certificates are correctly
// reported
TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
@ -1559,4 +1461,4 @@ TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);
}
} // namespace webrtc
} // namespace

24
talk/app/webrtc/statstypes.cc
View File

@ -34,9 +34,7 @@ const char StatsReport::kStatsReportTypeBwe[] = "VideoBwe";
const char StatsReport::kStatsReportTypeRemoteSsrc[] = "remoteSsrc";
const char StatsReport::kStatsReportTypeSsrc[] = "ssrc";
const char StatsReport::kStatsReportTypeTrack[] = "googTrack";
const char StatsReport::kStatsReportTypeIceLocalCandidate[] = "localcandidate";
const char StatsReport::kStatsReportTypeIceRemoteCandidate[] =
"remotecandidate";
const char StatsReport::kStatsReportTypeIceCandidate[] = "iceCandidate";
const char StatsReport::kStatsReportTypeTransport[] = "googTransport";
const char StatsReport::kStatsReportTypeComponent[] = "googComponent";
const char StatsReport::kStatsReportTypeCandidatePair[] = "googCandidatePair";
@ -137,22 +135,6 @@ const char* StatsReport::Value::display_name() const {
return "googCaptureJitterMs";
case kStatsValueNameCaptureQueueDelayMsPerS:
return "googCaptureQueueDelayMsPerS";
// Candidate related attributes. Values are taken from
// http://w3c.github.io/webrtc-stats/#rtcstatstype-enum*.
case kStatsValueNameCandidateIPAddress:
return "ipAddress";
case kStatsValueNameCandidateNetworkType:
return "networkType";
case kStatsValueNameCandidatePortNumber:
return "portNumber";
case kStatsValueNameCandidatePriority:
return "priority";
case kStatsValueNameCandidateTransportType:
return "transport";
case kStatsValueNameCandidateType:
return "candidateType";
case kStatsValueNameChannelId:
return "googChannelId";
case kStatsValueNameCodecName:
@ -245,8 +227,6 @@ const char* StatsReport::Value::display_name() const {
return "googJitterReceived";
case kStatsValueNameLocalAddress:
return "googLocalAddress";
case kStatsValueNameLocalCandidateId:
return "localCandidateId";
case kStatsValueNameLocalCandidateType:
return "googLocalCandidateType";
case kStatsValueNameLocalCertificateId:
@ -273,8 +253,6 @@ const char* StatsReport::Value::display_name() const {
return "googReceivedPacketGroupPropagationDeltaSumDebug";
case kStatsValueNameRemoteAddress:
return "googRemoteAddress";
case kStatsValueNameRemoteCandidateId:
return "remoteCandidateId";
case kStatsValueNameRemoteCandidateType:
return "googRemoteCandidateType";
case kStatsValueNameRemoteCertificateId:

17
talk/app/webrtc/statstypes.h
View File

@ -97,12 +97,6 @@ class StatsReport {
kStatsValueNameCaptureJitterMs,
kStatsValueNameCaptureQueueDelayMsPerS,
kStatsValueNameCaptureStartNtpTimeMs,
kStatsValueNameCandidateIPAddress,
kStatsValueNameCandidateNetworkType,
kStatsValueNameCandidatePortNumber,
kStatsValueNameCandidatePriority,
kStatsValueNameCandidateTransportType,
kStatsValueNameCandidateType,
kStatsValueNameChannelId,
kStatsValueNameCodecName,
kStatsValueNameComponent,
@ -144,7 +138,6 @@ class StatsReport {
kStatsValueNameJitterBufferMs,
kStatsValueNameJitterReceived,
kStatsValueNameLocalAddress,
kStatsValueNameLocalCandidateId,
kStatsValueNameLocalCandidateType,
kStatsValueNameLocalCertificateId,
kStatsValueNameMaxDecodeMs,
@ -158,7 +151,6 @@ class StatsReport {
kStatsValueNameRecvPacketGroupPropagationDeltaDebug,
kStatsValueNameRecvPacketGroupPropagationDeltaSumDebug,
kStatsValueNameRemoteAddress,
kStatsValueNameRemoteCandidateId,
kStatsValueNameRemoteCandidateType,
kStatsValueNameRemoteCertificateId,
kStatsValueNameRenderDelayMs,
@ -245,12 +237,9 @@ class StatsReport {
// track. The |id| field is the track id.
static const char kStatsReportTypeTrack[];
// StatsReport of |type| = "localcandidate" or "remotecandidate" is attributes
// on a specific ICE Candidate. It links to its connection pair by candidate
// id. The string value is taken from
// http://w3c.github.io/webrtc-stats/#rtcstatstype-enum*.
static const char kStatsReportTypeIceLocalCandidate[];
static const char kStatsReportTypeIceRemoteCandidate[];
// StatsReport of |type| = "iceCandidate" is statistics on a specific
// ICE Candidate. It links to its transport.
static const char kStatsReportTypeIceCandidate[];
// A StatsReport of |type| = "googCertificate" contains an SSL certificate
// transmitted by one of the endpoints of this connection. The |id| is

4
talk/app/webrtc/webrtcsdp.cc
View File

@ -1089,9 +1089,11 @@ bool ParseCandidate(const std::string& message, Candidate* candidate,
}
}
// Empty string as the candidate id and network name.
const std::string id;
const std::string network_name;
*candidate = Candidate(id, component_id, cricket::ProtoToString(protocol),
address, priority, username, password, candidate_type,
address, priority, username, password, candidate_type, network_name,
generation, foundation);
candidate->set_related_address(related_address);
candidate->set_tcptype(tcptype);

114
talk/app/webrtc/webrtcsdp_unittest.cc
View File

@ -588,74 +588,88 @@ class WebRtcSdpTest : public testing::Test {
// v4 host
int port = 1234;
rtc::SocketAddress address("192.168.1.5", port++);
Candidate candidate1("", ICE_CANDIDATE_COMPONENT_RTP, "udp", address,
kCandidatePriority, "", "", LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation1);
Candidate candidate1(
"", ICE_CANDIDATE_COMPONENT_RTP, "udp", address, kCandidatePriority,
"", "", LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation1);
address.SetPort(port++);
Candidate candidate2("", ICE_CANDIDATE_COMPONENT_RTCP, "udp", address,
kCandidatePriority, "", "", LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation1);
Candidate candidate2(
"", ICE_CANDIDATE_COMPONENT_RTCP, "udp", address, kCandidatePriority,
"", "", LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation1);
address.SetPort(port++);
Candidate candidate3("", ICE_CANDIDATE_COMPONENT_RTCP, "udp", address,
kCandidatePriority, "", "", LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation1);
Candidate candidate3(
"", ICE_CANDIDATE_COMPONENT_RTCP, "udp", address, kCandidatePriority,
"", "", LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation1);
address.SetPort(port++);
Candidate candidate4("", ICE_CANDIDATE_COMPONENT_RTP, "udp", address,
kCandidatePriority, "", "", LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation1);
Candidate candidate4(
"", ICE_CANDIDATE_COMPONENT_RTP, "udp", address, kCandidatePriority,
"", "", LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation1);
// v6 host
rtc::SocketAddress v6_address("::1", port++);
cricket::Candidate candidate5("", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", v6_address, kCandidatePriority, "", "",
cricket::LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation2);
cricket::Candidate candidate5(
"", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", v6_address, kCandidatePriority,
"", "", cricket::LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation2);
v6_address.SetPort(port++);
cricket::Candidate candidate6("", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", v6_address, kCandidatePriority, "", "",
cricket::LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation2);
cricket::Candidate candidate6(
"", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", v6_address, kCandidatePriority,
"", "", cricket::LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation2);
v6_address.SetPort(port++);
cricket::Candidate candidate7("", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", v6_address, kCandidatePriority, "", "",
cricket::LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation2);
cricket::Candidate candidate7(
"", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", v6_address, kCandidatePriority,
"", "", cricket::LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation2);
v6_address.SetPort(port++);
cricket::Candidate candidate8("", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", v6_address, kCandidatePriority, "", "",
cricket::LOCAL_PORT_TYPE,
kCandidateGeneration, kCandidateFoundation2);
cricket::Candidate candidate8(
"", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", v6_address, kCandidatePriority,
"", "", cricket::LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation2);
// stun
int port_stun = 2345;
rtc::SocketAddress address_stun("74.125.127.126", port_stun++);
rtc::SocketAddress rel_address_stun("192.168.1.5", port_stun++);
cricket::Candidate candidate9("", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", address_stun, kCandidatePriority, "",
"", STUN_PORT_TYPE, kCandidateGeneration,
kCandidateFoundation3);
cricket::Candidate candidate9
("", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", address_stun, kCandidatePriority,
"", "", STUN_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation3);
candidate9.set_related_address(rel_address_stun);
address_stun.SetPort(port_stun++);
rel_address_stun.SetPort(port_stun++);
cricket::Candidate candidate10("", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", address_stun, kCandidatePriority, "",
"", STUN_PORT_TYPE, kCandidateGeneration,
kCandidateFoundation3);
cricket::Candidate candidate10(
"", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", address_stun, kCandidatePriority,
"", "", STUN_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation3);
candidate10.set_related_address(rel_address_stun);
// relay
int port_relay = 3456;
rtc::SocketAddress address_relay("74.125.224.39", port_relay++);
cricket::Candidate candidate11("", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", address_relay, kCandidatePriority, "",
"", cricket::RELAY_PORT_TYPE,
cricket::Candidate candidate11(
"", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
"udp", address_relay, kCandidatePriority,
"", "",
cricket::RELAY_PORT_TYPE, "",
kCandidateGeneration, kCandidateFoundation4);
address_relay.SetPort(port_relay++);
cricket::Candidate candidate12("", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", address_relay, kCandidatePriority, "",
"", RELAY_PORT_TYPE, kCandidateGeneration,
kCandidateFoundation4);
cricket::Candidate candidate12(
"", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", address_relay, kCandidatePriority,
"", "",
RELAY_PORT_TYPE, "",
kCandidateGeneration, kCandidateFoundation4);
// voice
candidates_.push_back(candidate1);
@ -1628,10 +1642,11 @@ TEST_F(WebRtcSdpTest, SerializeCandidates) {
// TODO(mallinath) : Enable this test once WebRTCSdp capable of parsing
// RFC 6544.
TEST_F(WebRtcSdpTest, SerializeTcpCandidates) {
Candidate candidate("", ICE_CANDIDATE_COMPONENT_RTP, "tcp",
Candidate candidate(
"", ICE_CANDIDATE_COMPONENT_RTP, "tcp",
rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
"", "", LOCAL_PORT_TYPE, kCandidateGeneration,
kCandidateFoundation1);
"", "", LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation1);
candidate.set_tcptype(cricket::TCPTYPE_ACTIVE_STR);
rtc::scoped_ptr<IceCandidateInterface> jcandidate(
new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
@ -1921,10 +1936,11 @@ TEST_F(WebRtcSdpTest, DeserializeCandidate) {
sdp = kSdpTcpActiveCandidate;
EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
// Make a cricket::Candidate equivalent to kSdpTcpCandidate string.
Candidate candidate("", ICE_CANDIDATE_COMPONENT_RTP, "tcp",
Candidate candidate(
"", ICE_CANDIDATE_COMPONENT_RTP, "tcp",
rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
"", "", LOCAL_PORT_TYPE, kCandidateGeneration,
kCandidateFoundation1);
"", "", LOCAL_PORT_TYPE,
"", kCandidateGeneration, kCandidateFoundation1);
rtc::scoped_ptr<IceCandidateInterface> jcandidate_template(
new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
EXPECT_TRUE(jcandidate.candidate().IsEquivalent(

26
webrtc/base/network.cc
View File

@ -65,14 +65,6 @@ const int kNetworksUpdateIntervalMs = 2000;
const int kHighestNetworkPreference = 127;
// Strings used by the stats collector to report adapter types. This fits the
// general stype of http://w3c.github.io/webrtc-stats than what
// AdapterTypeToString does.
const char* STATSREPORT_ADAPTER_TYPE_ETHERNET = "lan";
const char* STATSREPORT_ADAPTER_TYPE_WIFI = "wlan";
const char* STATSREPORT_ADAPTER_TYPE_WWAN = "wwan";
const char* STATSREPORT_ADAPTER_TYPE_VPN = "vpn";
typedef struct {
Network* net;
std::vector<InterfaceAddress> ips;
@ -131,24 +123,6 @@ std::string AdapterTypeToString(AdapterType type) {
} // namespace
const char* AdapterTypeToStatsType(rtc::AdapterType type) {
switch (type) {
case ADAPTER_TYPE_UNKNOWN:
return "unknown";
case ADAPTER_TYPE_ETHERNET:
return STATSREPORT_ADAPTER_TYPE_ETHERNET;
case ADAPTER_TYPE_WIFI:
return STATSREPORT_ADAPTER_TYPE_WIFI;
case ADAPTER_TYPE_CELLULAR:
return STATSREPORT_ADAPTER_TYPE_WWAN;
case ADAPTER_TYPE_VPN:
return STATSREPORT_ADAPTER_TYPE_VPN;
default:
ASSERT(false);
return "";
}
}
std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
int prefix_length) {
std::ostringstream ost;

5
webrtc/base/network.h
View File

@ -39,11 +39,6 @@ enum AdapterType {
ADAPTER_TYPE_VPN = 4
};
// Conversion function to convert adapter type to report string which are more
// fitting to the general style of http://w3c.github.io/webrtc-stats. This is
// only used by stats collector.
const char* AdapterTypeToStatsType(rtc::AdapterType type);
// Makes a string key for this network. Used in the network manager's maps.
// Network objects are keyed on interface name, network prefix and the
// length of that prefix.

45
webrtc/p2p/base/candidate.h
View File

@ -20,7 +20,6 @@
#include "webrtc/p2p/base/constants.h"
#include "webrtc/base/basictypes.h"
#include "webrtc/base/network.h"
#include "webrtc/base/socketaddress.h"
namespace cricket {
@ -31,33 +30,17 @@ class Candidate {
public:
// TODO: Match the ordering and param list as per RFC 5245
// candidate-attribute syntax. http://tools.ietf.org/html/rfc5245#section-15.1
Candidate()
: component_(0),
priority_(0),
network_type_(rtc::ADAPTER_TYPE_UNKNOWN),
generation_(0) {}
Candidate(const std::string& id,
int component,
const std::string& protocol,
const rtc::SocketAddress& address,
uint32 priority,
const std::string& username,
const std::string& password,
const std::string& type,
uint32 generation,
const std::string& foundation)
: id_(id),
component_(component),
protocol_(protocol),
address_(address),
priority_(priority),
username_(username),
password_(password),
type_(type),
network_type_(rtc::ADAPTER_TYPE_UNKNOWN),
generation_(generation),
foundation_(foundation) {}
Candidate() : component_(0), priority_(0), generation_(0) {}
Candidate(const std::string& id, int component, const std::string& protocol,
const rtc::SocketAddress& address, uint32 priority,
const std::string& username, const std::string& password,
const std::string& type, const std::string& network_name,
uint32 generation, const std::string& foundation)
: id_(id), component_(component), protocol_(protocol), address_(address),
priority_(priority), username_(username), password_(password),
type_(type), network_name_(network_name), generation_(generation),
foundation_(foundation) {
}
const std::string & id() const { return id_; }
void set_id(const std::string & id) { id_ = id; }
@ -111,11 +94,6 @@ class Candidate {
network_name_ = network_name;
}
rtc::AdapterType network_type() const { return network_type_; }
void set_network_type(rtc::AdapterType network_type) {
network_type_ = network_type;
}
// Candidates in a new generation replace those in the old generation.
uint32 generation() const { return generation_; }
void set_generation(uint32 generation) { generation_ = generation; }
@ -223,7 +201,6 @@ class Candidate {
std::string password_;
std::string type_;
std::string network_name_;
rtc::AdapterType network_type_;
uint32 generation_;
std::string foundation_;
rtc::SocketAddress related_address_;

7
webrtc/p2p/base/p2ptransportchannel.cc
View File

@ -506,9 +506,10 @@ void P2PTransportChannel::OnUnknownAddress(
}
std::string id = rtc::CreateRandomString(8);
new_remote_candidate =
Candidate(id, component(), ProtoToString(proto), address, 0,
remote_username, remote_password, type, 0U,
new_remote_candidate = Candidate(
id, component(), ProtoToString(proto), address,
0, remote_username, remote_password, type,
port->Network()->name(), 0U,
rtc::ToString<uint32>(rtc::ComputeCrc32(id)));
new_remote_candidate.set_priority(
new_remote_candidate.GetPriority(ICE_TYPE_PREFERENCE_SRFLX,

27
webrtc/p2p/base/port.cc
View File

@ -26,14 +26,6 @@
namespace {
// The following is the enum RTCStatsIceCandidateType from
// http://w3c.github.io/webrtc-stats/#rtcstatsicecandidatetype-enum such that
// our stats report for ice candidate type could conform to that.
const char STATSREPORT_LOCAL_PORT_TYPE[] = "host";
const char STATSREPORT_STUN_PORT_TYPE[] = "serverreflexive";
const char STATSREPORT_PRFLX_PORT_TYPE[] = "peerreflexive";
const char STATSREPORT_RELAY_PORT_TYPE[] = "relayed";
// Determines whether we have seen at least the given maximum number of
// pings fail to have a response.
inline bool TooManyFailures(
@ -139,23 +131,6 @@ bool StringToProto(const char* value, ProtocolType* proto) {
return false;
}
const char* IceCandidateTypeToStatsType(const std::string& candidate_type) {
if (candidate_type == LOCAL_PORT_TYPE) {
return STATSREPORT_LOCAL_PORT_TYPE;
}
if (candidate_type == STUN_PORT_TYPE) {
return STATSREPORT_STUN_PORT_TYPE;
}
if (candidate_type == PRFLX_PORT_TYPE) {
return STATSREPORT_PRFLX_PORT_TYPE;
}
if (candidate_type == RELAY_PORT_TYPE) {
return STATSREPORT_RELAY_PORT_TYPE;
}
ASSERT(false);
return "unknown";
}
// RFC 6544, TCP candidate encoding rules.
const int DISCARD_PORT = 9;
const char TCPTYPE_ACTIVE_STR[] = "active";
@ -295,7 +270,6 @@ void Port::AddAddress(const rtc::SocketAddress& address,
c.set_username(username_fragment());
c.set_password(password_);
c.set_network_name(network_->name());
c.set_network_type(network_->type());
c.set_generation(generation_);
c.set_related_address(related_address);
c.set_foundation(ComputeFoundation(type, protocol, base_address));
@ -1456,7 +1430,6 @@ void Connection::MaybeAddPrflxCandidate(ConnectionRequest* request,
new_local_candidate.set_username(local_candidate().username());
new_local_candidate.set_password(local_candidate().password());
new_local_candidate.set_network_name(local_candidate().network_name());
new_local_candidate.set_network_type(local_candidate().network_type());
new_local_candidate.set_related_address(local_candidate().address());
new_local_candidate.set_foundation(
ComputeFoundation(PRFLX_PORT_TYPE, local_candidate().protocol(),

4
webrtc/p2p/base/port.h
View File

@ -88,10 +88,6 @@ enum IcePriorityValue {
const char* ProtoToString(ProtocolType proto);
bool StringToProto(const char* value, ProtocolType* proto);
// Conversion function to convert candidate type string to the corresponding one
// from enum RTCStatsIceCandidateType.
const char* IceCandidateTypeToStatsType(const std::string& candidate_type);
struct ProtocolAddress {
rtc::SocketAddress address;
ProtocolType proto;

21
webrtc/p2p/base/transport_unittest.cc
View File

@ -18,7 +18,6 @@
#include "webrtc/libjingle/xmpp/constants.h"
#include "webrtc/base/fakesslidentity.h"
#include "webrtc/base/gunit.h"
#include "webrtc/base/network.h"
#include "webrtc/base/thread.h"
using cricket::Candidate;
@ -347,19 +346,19 @@ TEST_F(TransportTest, TestSetRemoteIceLiteInAnswer) {
// Tests that we can properly serialize/deserialize candidates.
TEST_F(TransportTest, TestP2PTransportWriteAndParseCandidate) {
Candidate test_candidate("", 1, "udp",
Candidate test_candidate(
"", 1, "udp",
rtc::SocketAddress("2001:db8:fefe::1", 9999),
738197504, "abcdef", "ghijkl", "foo", 50, "");
test_candidate.set_network_name("testnet");
Candidate test_candidate2("", 2, "tcp",
rtc::SocketAddress("192.168.7.1", 9999), 1107296256,
"mnopqr", "stuvwx", "bar", 100, "");
test_candidate2.set_network_name("testnet2");
738197504, "abcdef", "ghijkl", "foo", "testnet", 50, "");
Candidate test_candidate2(
"", 2, "tcp",
rtc::SocketAddress("192.168.7.1", 9999),
1107296256, "mnopqr", "stuvwx", "bar", "testnet2", 100, "");
rtc::SocketAddress host_address("www.google.com", 24601);
host_address.SetResolvedIP(rtc::IPAddress(0x0A000001));
Candidate test_candidate3("", 3, "spdy", host_address, 1476395008, "yzabcd",
"efghij", "baz", 150, "");
test_candidate3.set_network_name("testnet3");
Candidate test_candidate3(
"", 3, "spdy", host_address, 1476395008, "yzabcd",
"efghij", "baz", "testnet3", 150, "");
WriteError write_error;
ParseError parse_error;
rtc::scoped_ptr<buzz::XmlElement> elem;