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::WritePacket( |
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, |
33 const IPEndPoint& peer_address) { | |
31 scoped_refptr<StringIOBuffer> buf( | 34 scoped_refptr<StringIOBuffer> buf( |
32 new StringIOBuffer(std::string(buffer, buf_len))); | 35 new StringIOBuffer(std::string(buffer, buf_len))); |
33 DCHECK(!IsWriteBlocked()); | 36 DCHECK(!IsWriteBlocked()); |
37 DCHECK(!callback_.is_null()); | |
34 int rv = socket_->SendTo(buf.get(), | 38 int rv = socket_->SendTo(buf.get(), |
35 buf_len, | 39 buf_len, |
36 peer_address, | 40 peer_address, |
37 base::Bind(&QuicServerPacketWriter::OnWriteComplete, | 41 base::Bind(&QuicServerPacketWriter::OnWriteComplete, |
38 weak_factory_.GetWeakPtr())); | 42 weak_factory_.GetWeakPtr())); |
39 WriteStatus status = WRITE_STATUS_OK; | 43 WriteStatus status = WRITE_STATUS_OK; |
40 if (rv < 0) { | 44 if (rv < 0) { |
41 if (rv != ERR_IO_PENDING) { | 45 if (rv != ERR_IO_PENDING) { |
42 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.WriteError", -rv); | 46 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.WriteError", -rv); |
43 status = WRITE_STATUS_ERROR; | 47 status = WRITE_STATUS_ERROR; |
44 } else { | 48 } else { |
45 status = WRITE_STATUS_BLOCKED; | 49 status = WRITE_STATUS_BLOCKED; |
46 write_blocked_ = true; | 50 write_blocked_ = true; |
47 } | 51 } |
48 } | 52 } |
53 return WriteResult(status, rv); | |
54 } | |
49 | 55 |
50 return WriteResult(status, rv); | 56 WriteResult QuicServerPacketWriter::WritePacketWithCallback( |
57 const char* buffer, | |
58 size_t buf_len, | |
59 const IPAddressNumber& self_address, | |
60 const IPEndPoint& peer_address, | |
61 WriteCallback callback) { | |
62 DCHECK(callback_.is_null()); | |
63 callback_ = callback; | |
64 WriteResult result = WritePacket(buffer, buf_len, self_address, peer_address); | |
65 if (result.status != WRITE_STATUS_BLOCKED) { | |
66 callback_.Reset(); | |
67 } | |
wtc
2014/06/23 23:12:16
If it is safe to do so, it is cheaper to do this:
dmziegler
2014/06/24 00:08:53
I wanted to use the DCHECK(!callback_.is_null()) i
| |
68 return result; | |
51 } | 69 } |
52 | 70 |
53 bool QuicServerPacketWriter::IsWriteBlockedDataBuffered() const { | 71 bool QuicServerPacketWriter::IsWriteBlockedDataBuffered() const { |
54 // UDPServerSocket::SendTo buffers the data until the Write is permitted. | 72 // UDPServerSocket::SendTo buffers the data until the Write is permitted. |
55 return true; | 73 return true; |
56 } | 74 } |
57 | 75 |
58 bool QuicServerPacketWriter::IsWriteBlocked() const { | 76 bool QuicServerPacketWriter::IsWriteBlocked() const { |
59 return write_blocked_; | 77 return write_blocked_; |
60 } | 78 } |
61 | 79 |
62 void QuicServerPacketWriter::SetWritable() { | 80 void QuicServerPacketWriter::SetWritable() { |
63 write_blocked_ = false; | 81 write_blocked_ = false; |
64 } | 82 } |
65 | 83 |
66 void QuicServerPacketWriter::OnWriteComplete(int rv) { | 84 void QuicServerPacketWriter::OnWriteComplete(int rv) { |
67 DCHECK_NE(rv, ERR_IO_PENDING); | 85 DCHECK_NE(rv, ERR_IO_PENDING); |
68 write_blocked_ = false; | 86 write_blocked_ = false; |
69 WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv); | 87 WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv); |
70 connection_->OnPacketSent(result); | 88 base::ResetAndReturn(&callback_).Run(result); |
71 connection_->OnCanWrite(); | 89 blocked_writer_->OnCanWrite(); |
72 } | 90 } |
73 | 91 |
74 } // namespace net | 92 } // namespace net |
OLD | NEW |