Allow p2p UDP packages to set DSCP

content/browser/renderer_host/p2p/socket_host_udp_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/p2p/socket_host_udp.h"
 
 #include <deque>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 132 matching lines @@
   virtual int SetMulticastTimeToLive(int time_to_live) OVERRIDE {
     NOTIMPLEMENTED();
     return net::ERR_NOT_IMPLEMENTED;
   }
 
   virtual int SetMulticastLoopbackMode(bool loopback) OVERRIDE {
     NOTIMPLEMENTED();
     return net::ERR_NOT_IMPLEMENTED;
   }
 
+  virtual int SetDiffServCodePoint(net::DiffServCodePoint dscp) OVERRIDE {
+    NOTIMPLEMENTED();
+    return net::ERR_NOT_IMPLEMENTED;
+  }
+
  private:
   net::IPEndPoint address_;
   std::deque<UDPPacket>* sent_packets_;
   std::deque<UDPPacket> incoming_packets_;
   net::BoundNetLog net_log_;
 
   scoped_refptr<net::IOBuffer> recv_buffer_;
   net::IPEndPoint* recv_address_;
   int recv_size_;
   net::CompletionCallback recv_callback_;
@@ skipping 39 matching lines @@
 // Verify that we can send STUN messages before we receive anything
 // from the other side.
 TEST_F(P2PSocketHostUdpTest, SendStunNoAuth) {
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
       .Times(3)
       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 
   std::vector<char> packet1;
   CreateStunRequest(&packet1);
-  socket_host_->Send(dest1_, packet1, 0);
+  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
 
   std::vector<char> packet2;
   CreateStunResponse(&packet2);
-  socket_host_->Send(dest1_, packet2, 0);
+  socket_host_->Send(dest1_, packet2, net::DSCP_NO_CHANGE, 0);
 
   std::vector<char> packet3;
   CreateStunError(&packet3);
-  socket_host_->Send(dest1_, packet3, 0);
+  socket_host_->Send(dest1_, packet3, net::DSCP_NO_CHANGE, 0);
 
   ASSERT_EQ(sent_packets_.size(), 3U);
   ASSERT_EQ(sent_packets_[0].second, packet1);
   ASSERT_EQ(sent_packets_[1].second, packet2);
   ASSERT_EQ(sent_packets_[2].second, packet3);
 }
 
 // Verify that no data packets can be sent before STUN binding has
 // finished.
 TEST_F(P2PSocketHostUdpTest, SendDataNoAuth) {
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 
   std::vector<char> packet;
   CreateRandomPacket(&packet);
-  socket_host_->Send(dest1_, packet, 0);
+  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE, 0);
 
   ASSERT_EQ(sent_packets_.size(), 0U);
 }
 
 // Verify that we can send data after we've received STUN request
 // from the other side.
 TEST_F(P2PSocketHostUdpTest, SendAfterStunRequest) {
   // Receive packet from |dest1_|.
   std::vector<char> request_packet;
   CreateStunRequest(&request_packet);
 
   EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   socket_->ReceivePacket(dest1_, request_packet);
 
   // Now we should be able to send any data to |dest1_|.
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   std::vector<char> packet;
   CreateRandomPacket(&packet);
-  socket_host_->Send(dest1_, packet, 0);
+  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE, 0);
 
   ASSERT_EQ(1U, sent_packets_.size());
   ASSERT_EQ(dest1_, sent_packets_[0].first);
 }
 
 // Verify that we can send data after we've received STUN response
 // from the other side.
 TEST_F(P2PSocketHostUdpTest, SendAfterStunResponse) {
   // Receive packet from |dest1_|.
   std::vector<char> request_packet;
   CreateStunRequest(&request_packet);
 
   EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   socket_->ReceivePacket(dest1_, request_packet);
 
   // Now we should be able to send any data to |dest1_|.
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   std::vector<char> packet;
   CreateRandomPacket(&packet);
-  socket_host_->Send(dest1_, packet, 0);
+  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE, 0);
 
   ASSERT_EQ(1U, sent_packets_.size());
   ASSERT_EQ(dest1_, sent_packets_[0].first);
 }
 
 // Verify messages still cannot be sent to an unathorized host after
 // successful binding with different host.
 TEST_F(P2PSocketHostUdpTest, SendAfterStunResponseDifferentHost) {
   // Receive packet from |dest1_|.
   std::vector<char> request_packet;
   CreateStunRequest(&request_packet);
 
   EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   socket_->ReceivePacket(dest1_, request_packet);
 
   // Should fail when trying to send the same packet to |dest2_|.
   std::vector<char> packet;
   CreateRandomPacket(&packet);
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
-  socket_host_->Send(dest2_, packet, 0);
+  socket_host_->Send(dest2_, packet, net::DSCP_NO_CHANGE, 0);
 }
 
 // Verify throttler not allowing unlimited sending of ICE messages to
 // any destination.
 TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimit) {
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
       .Times(2)
       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 
   std::vector<char> packet1;
   CreateStunRequest(&packet1);
   throttler_.SetSendIceBandwidth(packet1.size() * 2);
-  socket_host_->Send(dest1_, packet1, 0);
-  socket_host_->Send(dest2_, packet1, 0);
+  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
+  socket_host_->Send(dest2_, packet1, net::DSCP_NO_CHANGE, 0);
 
   net::IPEndPoint dest3 = ParseAddress(kTestIpAddress1, 2222);
   // This packet must be dropped by the throttler.
-  socket_host_->Send(dest3, packet1, 0);
+  socket_host_->Send(dest3, packet1, net::DSCP_NO_CHANGE, 0);
   ASSERT_EQ(sent_packets_.size(), 2U);
 }
 
 // Verify we can send packets to a known destination when ICE throttling is
 // active.
 TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimitAfterReceive) {
   // Receive packet from |dest1_|.
   std::vector<char> request_packet;
   CreateStunRequest(&request_packet);
 
   EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
   socket_->ReceivePacket(dest1_, request_packet);
 
   EXPECT_CALL(sender_, Send(
       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
       .Times(4)
       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 
   std::vector<char> packet1;
   CreateStunRequest(&packet1);
   throttler_.SetSendIceBandwidth(packet1.size());
   // |dest1_| is known address, throttling will not be applied.
-  socket_host_->Send(dest1_, packet1, 0);
+  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
   // Trying to send the packet to dest1_ in the same window. It should go.
-  socket_host_->Send(dest1_, packet1, 0);
+  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
 
   // Throttler should allow this packet to go through.
-  socket_host_->Send(dest2_, packet1, 0);
+  socket_host_->Send(dest2_, packet1, net::DSCP_NO_CHANGE, 0);
 
   net::IPEndPoint dest3 = ParseAddress(kTestIpAddress1, 2223);
   // This packet will be dropped, as limit only for a single packet.
-  socket_host_->Send(dest3, packet1, 0);
+  socket_host_->Send(dest3, packet1, net::DSCP_NO_CHANGE, 0);
   net::IPEndPoint dest4 = ParseAddress(kTestIpAddress1, 2224);
   // This packet should also be dropped.
-  socket_host_->Send(dest4, packet1, 0);
+  socket_host_->Send(dest4, packet1, net::DSCP_NO_CHANGE, 0);
   // |dest1| is known, we can send as many packets to it.
-  socket_host_->Send(dest1_, packet1, 0);
+  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
   ASSERT_EQ(sent_packets_.size(), 4U);
 }
 
 }  // namespace content