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 120 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 SetToS(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 35 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);
+  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE);
 
   std::vector<char> packet2;
   CreateStunResponse(&packet2);
-  socket_host_->Send(dest1_, packet2);
+  socket_host_->Send(dest1_, packet2, net::DSCP_NO_CHANGE);
 
   std::vector<char> packet3;
   CreateStunError(&packet3);
-  socket_host_->Send(dest1_, packet3);
+  socket_host_->Send(dest1_, packet3, net::DSCP_NO_CHANGE);
 
   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);
+  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE);
 
   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);
+  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE);
 
   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);
+  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE);
 
   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);
+  socket_host_->Send(dest2_, packet, net::DSCP_NO_CHANGE);
 }
 
 }  // namespace content