OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/quic_server_packet_writer.h" | 5 #include "net/quic/quic_server_packet_writer.h" |
6 | 6 |
7 #include "base/callback_helpers.h" | |
7 #include "base/location.h" | 8 #include "base/location.h" |
8 #include "base/logging.h" | 9 #include "base/logging.h" |
9 #include "base/metrics/sparse_histogram.h" | 10 #include "base/metrics/sparse_histogram.h" |
10 #include "net/base/io_buffer.h" | 11 #include "net/base/io_buffer.h" |
11 #include "net/base/net_errors.h" | 12 #include "net/base/net_errors.h" |
13 #include "net/udp/udp_server_socket.h" | |
12 | 14 |
13 namespace net { | 15 namespace net { |
14 | 16 |
15 QuicServerPacketWriter::QuicServerPacketWriter() : weak_factory_(this) { | 17 QuicServerPacketWriter::QuicServerPacketWriter( |
16 } | 18 UDPServerSocket* socket, |
17 | 19 QuicBlockedWriterInterface* blocked_writer) |
18 QuicServerPacketWriter::QuicServerPacketWriter(UDPServerSocket* socket) | |
19 : weak_factory_(this), | 20 : weak_factory_(this), |
20 socket_(socket), | 21 socket_(socket), |
22 blocked_writer_(blocked_writer), | |
21 write_blocked_(false) { | 23 write_blocked_(false) { |
22 } | 24 } |
23 | 25 |
24 QuicServerPacketWriter::~QuicServerPacketWriter() { | 26 QuicServerPacketWriter::~QuicServerPacketWriter() { |
25 } | 27 } |
26 | 28 |
27 WriteResult QuicServerPacketWriter::WritePacket( | 29 WriteResult QuicServerPacketWriter::WritePacketWithCallback( |
28 const char* buffer, size_t buf_len, | 30 const char* buffer, |
29 const net::IPAddressNumber& self_address, | 31 size_t buf_len, |
30 const net::IPEndPoint& peer_address) { | 32 const IPAddressNumber& self_address, |
31 scoped_refptr<StringIOBuffer> buf( | 33 const IPEndPoint& peer_address, |
32 new StringIOBuffer(std::string(buffer, buf_len))); | 34 WriteCallback callback) { |
33 DCHECK(!IsWriteBlocked()); | 35 DCHECK(callback_.is_null()); |
34 int rv = socket_->SendTo(buf.get(), | 36 callback_ = callback; |
35 buf_len, | 37 WriteResult result = WritePacket(buffer, buf_len, self_address, peer_address); |
36 peer_address, | 38 if (result.status != WRITE_STATUS_BLOCKED) { |
37 base::Bind(&QuicServerPacketWriter::OnWriteComplete, | 39 callback_.Reset(); |
38 weak_factory_.GetWeakPtr())); | |
39 WriteStatus status = WRITE_STATUS_OK; | |
40 if (rv < 0) { | |
41 if (rv != ERR_IO_PENDING) { | |
42 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.WriteError", -rv); | |
43 status = WRITE_STATUS_ERROR; | |
44 } else { | |
45 status = WRITE_STATUS_BLOCKED; | |
46 write_blocked_ = true; | |
47 } | |
48 } | 40 } |
41 return result; | |
42 } | |
49 | 43 |
50 return WriteResult(status, rv); | 44 void QuicServerPacketWriter::OnWriteComplete(int rv) { |
45 DCHECK_NE(rv, ERR_IO_PENDING); | |
46 write_blocked_ = false; | |
47 WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv); | |
48 base::ResetAndReturn(&callback_).Run(result); | |
49 blocked_writer_->OnCanWrite(); | |
51 } | 50 } |
52 | 51 |
53 bool QuicServerPacketWriter::IsWriteBlockedDataBuffered() const { | 52 bool QuicServerPacketWriter::IsWriteBlockedDataBuffered() const { |
54 // UDPServerSocket::SendTo buffers the data until the Write is permitted. | 53 // UDPServerSocket::SendTo buffers the data until the Write is permitted. |
55 return true; | 54 return true; |
56 } | 55 } |
57 | 56 |
58 bool QuicServerPacketWriter::IsWriteBlocked() const { | 57 bool QuicServerPacketWriter::IsWriteBlocked() const { |
59 return write_blocked_; | 58 return write_blocked_; |
60 } | 59 } |
61 | 60 |
62 void QuicServerPacketWriter::SetWritable() { | 61 void QuicServerPacketWriter::SetWritable() { |
63 write_blocked_ = false; | 62 write_blocked_ = false; |
64 } | 63 } |
65 | 64 |
66 void QuicServerPacketWriter::OnWriteComplete(int rv) { | 65 WriteResult QuicServerPacketWriter::WritePacket( |
67 DCHECK_NE(rv, ERR_IO_PENDING); | 66 const char* buffer, |
68 write_blocked_ = false; | 67 size_t buf_len, |
69 WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv); | 68 const IPAddressNumber& self_address, |
70 connection_->OnPacketSent(result); | 69 const IPEndPoint& peer_address) { |
71 connection_->OnCanWrite(); | 70 scoped_refptr<StringIOBuffer> buf( |
71 new StringIOBuffer(std::string(buffer, buf_len))); | |
72 DCHECK(!IsWriteBlocked()); | |
73 DCHECK(!callback_.is_null()); | |
74 int rv; | |
75 if (buf_len <= static_cast<size_t>(std::numeric_limits<int>::max())) { | |
wtc
2014/06/24 21:47:21
I confirm this check is correct.
| |
76 rv = socket_->SendTo(buf.get(), | |
77 static_cast<int>(buf_len), | |
78 peer_address, | |
79 base::Bind(&QuicServerPacketWriter::OnWriteComplete, | |
80 weak_factory_.GetWeakPtr())); | |
81 } else { | |
82 rv = ERR_MSG_TOO_BIG; | |
83 } | |
84 WriteStatus status = WRITE_STATUS_OK; | |
85 if (rv < 0) { | |
86 if (rv != ERR_IO_PENDING) { | |
87 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.WriteError", -rv); | |
88 status = WRITE_STATUS_ERROR; | |
89 } else { | |
90 status = WRITE_STATUS_BLOCKED; | |
91 write_blocked_ = true; | |
92 } | |
93 } | |
94 return WriteResult(status, rv); | |
72 } | 95 } |
73 | 96 |
74 } // namespace net | 97 } // namespace net |
OLD | NEW |