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; int port = 1234;
rtc::SocketAddress address("127.0.0.1", port++); rtc::SocketAddress address("127.0.0.1", port++);
cricket::Candidate candidate("rtp", cricket::ICE_CANDIDATE_COMPONENT_RTP, cricket::Candidate candidate("rtp", cricket::ICE_CANDIDATE_COMPONENT_RTP,
"udp", address, 1, "", "", "local", 0, "1"); "udp", address, 1, "",
"", "local", "eth0", 0, "1");
candidate_ = candidate; candidate_ = candidate;
const std::string session_id = const std::string session_id =
rtc::ToString(rtc::CreateRandomId64()); 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); 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() { void StatsCollector::ExtractSessionInfo() {
ASSERT(session_->signaling_thread()->IsCurrent()); ASSERT(session_->signaling_thread()->IsCurrent());
// Extract information from the base session. // Extract information from the base session.
@ -742,15 +711,6 @@ void StatsCollector::ExtractSessionInfo() {
info.readable); info.readable);
report->AddBoolean(StatsReport::kStatsValueNameActiveConnection, report->AddBoolean(StatsReport::kStatsValueNameActiveConnection,
info.best_connection); 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, report->AddValue(StatsReport::kStatsValueNameLocalAddress,
info.local_candidate.address().ToString()); info.local_candidate.address().ToString());
report->AddValue(StatsReport::kStatsValueNameRemoteAddress, report->AddValue(StatsReport::kStatsValueNameRemoteAddress,

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

@ -93,19 +93,12 @@ class StatsCollector {
void ClearUpdateStatsCacheForTest(); void ClearUpdateStatsCacheForTest();
private: private:
friend class StatsCollectorTest;
bool CopySelectedReports(const std::string& selector, StatsReports* reports); bool CopySelectedReports(const std::string& selector, StatsReports* reports);
// Helper method for AddCertificateReports. // Helper method for AddCertificateReports.
std::string AddOneCertificateReport( std::string AddOneCertificateReport(
const rtc::SSLCertificate* cert, const std::string& issuer_id); 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 // Adds a report for this certificate and every certificate in its chain, and
// returns the leaf certificate's report's ID. // returns the leaf certificate's report's ID.
std::string AddCertificateReports(const rtc::SSLCertificate* cert); 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/base64.h"
#include "webrtc/base/fakesslidentity.h" #include "webrtc/base/fakesslidentity.h"
#include "webrtc/base/gunit.h" #include "webrtc/base/gunit.h"
#include "webrtc/base/network.h"
using cricket::StatsOptions; using cricket::StatsOptions;
using testing::_; using testing::_;
@ -62,7 +61,7 @@ class FakeDeviceManager;
} // namespace cricket } // namespace cricket
namespace webrtc { namespace {
// Error return values // Error return values
const char kNotFound[] = "NOT FOUND"; const char kNotFound[] = "NOT FOUND";
@ -502,12 +501,6 @@ class StatsCollectorTest : public testing::Test {
.WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true))); .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( void SetupAndVerifyAudioTrackStats(
FakeAudioTrack* audio_track, FakeAudioTrack* audio_track,
webrtc::MediaStream* stream, webrtc::MediaStream* stream,
@ -1023,97 +1016,6 @@ TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
EXPECT_EQ(kRemoteTrackId, track_id); 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 // This test verifies that all chained certificates are correctly
// reported // reported
TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) { TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
@ -1559,4 +1461,4 @@ TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports); 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::kStatsReportTypeRemoteSsrc[] = "remoteSsrc";
const char StatsReport::kStatsReportTypeSsrc[] = "ssrc"; const char StatsReport::kStatsReportTypeSsrc[] = "ssrc";
const char StatsReport::kStatsReportTypeTrack[] = "googTrack"; const char StatsReport::kStatsReportTypeTrack[] = "googTrack";
const char StatsReport::kStatsReportTypeIceLocalCandidate[] = "localcandidate"; const char StatsReport::kStatsReportTypeIceCandidate[] = "iceCandidate";
const char StatsReport::kStatsReportTypeIceRemoteCandidate[] =
"remotecandidate";
const char StatsReport::kStatsReportTypeTransport[] = "googTransport"; const char StatsReport::kStatsReportTypeTransport[] = "googTransport";
const char StatsReport::kStatsReportTypeComponent[] = "googComponent"; const char StatsReport::kStatsReportTypeComponent[] = "googComponent";
const char StatsReport::kStatsReportTypeCandidatePair[] = "googCandidatePair"; const char StatsReport::kStatsReportTypeCandidatePair[] = "googCandidatePair";
@ -137,22 +135,6 @@ const char* StatsReport::Value::display_name() const {
return "googCaptureJitterMs"; return "googCaptureJitterMs";
case kStatsValueNameCaptureQueueDelayMsPerS: case kStatsValueNameCaptureQueueDelayMsPerS:
return "googCaptureQueueDelayMsPerS"; 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: case kStatsValueNameChannelId:
return "googChannelId"; return "googChannelId";
case kStatsValueNameCodecName: case kStatsValueNameCodecName:
@ -245,8 +227,6 @@ const char* StatsReport::Value::display_name() const {
return "googJitterReceived"; return "googJitterReceived";
case kStatsValueNameLocalAddress: case kStatsValueNameLocalAddress:
return "googLocalAddress"; return "googLocalAddress";
case kStatsValueNameLocalCandidateId:
return "localCandidateId";
case kStatsValueNameLocalCandidateType: case kStatsValueNameLocalCandidateType:
return "googLocalCandidateType"; return "googLocalCandidateType";
case kStatsValueNameLocalCertificateId: case kStatsValueNameLocalCertificateId:
@ -273,8 +253,6 @@ const char* StatsReport::Value::display_name() const {
return "googReceivedPacketGroupPropagationDeltaSumDebug"; return "googReceivedPacketGroupPropagationDeltaSumDebug";
case kStatsValueNameRemoteAddress: case kStatsValueNameRemoteAddress:
return "googRemoteAddress"; return "googRemoteAddress";
case kStatsValueNameRemoteCandidateId:
return "remoteCandidateId";
case kStatsValueNameRemoteCandidateType: case kStatsValueNameRemoteCandidateType:
return "googRemoteCandidateType"; return "googRemoteCandidateType";
case kStatsValueNameRemoteCertificateId: case kStatsValueNameRemoteCertificateId:

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

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

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

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

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

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

26
webrtc/base/network.cc
View File

@ -65,14 +65,6 @@ const int kNetworksUpdateIntervalMs = 2000;
const int kHighestNetworkPreference = 127; 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 { typedef struct {
Network* net; Network* net;
std::vector<InterfaceAddress> ips; std::vector<InterfaceAddress> ips;
@ -131,24 +123,6 @@ std::string AdapterTypeToString(AdapterType type) {
} // namespace } // 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, std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
int prefix_length) { int prefix_length) {
std::ostringstream ost; std::ostringstream ost;

5
webrtc/base/network.h
View File

@ -39,11 +39,6 @@ enum AdapterType {
ADAPTER_TYPE_VPN = 4 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. // 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 // Network objects are keyed on interface name, network prefix and the
// length of that prefix. // length of that prefix.

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

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

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

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

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

@ -26,14 +26,6 @@
namespace { 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 // Determines whether we have seen at least the given maximum number of
// pings fail to have a response. // pings fail to have a response.
inline bool TooManyFailures( inline bool TooManyFailures(
@ -139,23 +131,6 @@ bool StringToProto(const char* value, ProtocolType* proto) {
return false; 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. // RFC 6544, TCP candidate encoding rules.
const int DISCARD_PORT = 9; const int DISCARD_PORT = 9;
const char TCPTYPE_ACTIVE_STR[] = "active"; const char TCPTYPE_ACTIVE_STR[] = "active";
@ -295,7 +270,6 @@ void Port::AddAddress(const rtc::SocketAddress& address,
c.set_username(username_fragment()); c.set_username(username_fragment());
c.set_password(password_); c.set_password(password_);
c.set_network_name(network_->name()); c.set_network_name(network_->name());
c.set_network_type(network_->type());
c.set_generation(generation_); c.set_generation(generation_);
c.set_related_address(related_address); c.set_related_address(related_address);
c.set_foundation(ComputeFoundation(type, protocol, base_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_username(local_candidate().username());
new_local_candidate.set_password(local_candidate().password()); new_local_candidate.set_password(local_candidate().password());
new_local_candidate.set_network_name(local_candidate().network_name()); 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_related_address(local_candidate().address());
new_local_candidate.set_foundation( new_local_candidate.set_foundation(
ComputeFoundation(PRFLX_PORT_TYPE, local_candidate().protocol(), 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); const char* ProtoToString(ProtocolType proto);
bool StringToProto(const char* value, 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 { struct ProtocolAddress {
rtc::SocketAddress address; rtc::SocketAddress address;
ProtocolType proto; ProtocolType proto;

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

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