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/location.h" | 7 #include "base/location.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "base/message_loop/message_loop.h" | |
wtc
2014/06/20 21:40:50
Delete this header.
dmziegler
2014/06/23 18:31:24
Done.
| |
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/quic/crypto/quic_random.h" | |
wtc
2014/06/20 21:40:50
I believe we can delete this header.
dmziegler
2014/06/23 18:31:24
Done.
| |
12 | 14 |
13 namespace net { | 15 namespace net { |
14 | 16 |
15 QuicServerPacketWriter::QuicServerPacketWriter() : weak_factory_(this) { | 17 QuicServerPacketWriter::QuicServerPacketWriter( |
16 } | 18 QuicBlockedWriterInterface* blocked_writer, |
17 | 19 UDPServerSocket* socket) |
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, size_t buf_len, |
29 const net::IPAddressNumber& self_address, | 31 const IPAddressNumber& self_address, |
30 const net::IPEndPoint& peer_address) { | 32 const IPEndPoint& peer_address) { |
31 scoped_refptr<StringIOBuffer> buf( | 33 scoped_refptr<StringIOBuffer> buf( |
32 new StringIOBuffer(std::string(buffer, buf_len))); | 34 new StringIOBuffer(std::string(buffer, buf_len))); |
33 DCHECK(!IsWriteBlocked()); | 35 DCHECK(!IsWriteBlocked()); |
34 int rv = socket_->SendTo(buf.get(), | 36 int rv = socket_->SendTo(buf.get(), |
35 buf_len, | 37 buf_len, |
36 peer_address, | 38 peer_address, |
37 base::Bind(&QuicServerPacketWriter::OnWriteComplete, | 39 base::Bind(&QuicServerPacketWriter::OnWriteComplete, |
38 weak_factory_.GetWeakPtr())); | 40 weak_factory_.GetWeakPtr())); |
39 WriteStatus status = WRITE_STATUS_OK; | 41 WriteStatus status = WRITE_STATUS_OK; |
40 if (rv < 0) { | 42 if (rv < 0) { |
41 if (rv != ERR_IO_PENDING) { | 43 if (rv != ERR_IO_PENDING) { |
42 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.WriteError", -rv); | 44 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.WriteError", -rv); |
43 status = WRITE_STATUS_ERROR; | 45 status = WRITE_STATUS_ERROR; |
44 } else { | 46 } else { |
45 status = WRITE_STATUS_BLOCKED; | 47 status = WRITE_STATUS_BLOCKED; |
46 write_blocked_ = true; | 48 write_blocked_ = true; |
47 } | 49 } |
48 } | 50 } |
51 return WriteResult(status, rv); | |
52 } | |
49 | 53 |
50 return WriteResult(status, rv); | 54 WriteResult QuicServerPacketWriter::WritePacketWithCallback( |
55 const char* buffer, | |
56 size_t buf_len, | |
57 const IPAddressNumber& self_address, | |
58 const IPEndPoint& peer_address, | |
59 WriteCallback callback) { | |
60 callback_ = callback; | |
61 return WritePacket(buffer, buf_len, self_address, peer_address); | |
wtc
2014/06/20 21:40:50
IMPORTANT: I think we should clear callback_ if Wr
dmziegler
2014/06/23 18:31:24
Done.
| |
51 } | 62 } |
52 | 63 |
53 bool QuicServerPacketWriter::IsWriteBlockedDataBuffered() const { | 64 bool QuicServerPacketWriter::IsWriteBlockedDataBuffered() const { |
54 // UDPServerSocket::SendTo buffers the data until the Write is permitted. | 65 // UDPServerSocket::SendTo buffers the data until the Write is permitted. |
55 return true; | 66 return true; |
56 } | 67 } |
57 | 68 |
58 bool QuicServerPacketWriter::IsWriteBlocked() const { | 69 bool QuicServerPacketWriter::IsWriteBlocked() const { |
59 return write_blocked_; | 70 return write_blocked_; |
60 } | 71 } |
61 | 72 |
62 void QuicServerPacketWriter::SetWritable() { | 73 void QuicServerPacketWriter::SetWritable() { |
63 write_blocked_ = false; | 74 write_blocked_ = false; |
64 } | 75 } |
65 | 76 |
66 void QuicServerPacketWriter::OnWriteComplete(int rv) { | 77 void QuicServerPacketWriter::OnWriteComplete(int rv) { |
67 DCHECK_NE(rv, ERR_IO_PENDING); | 78 DCHECK_NE(rv, ERR_IO_PENDING); |
68 write_blocked_ = false; | 79 write_blocked_ = false; |
69 WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv); | 80 WriteResult result(rv < 0 ? WRITE_STATUS_ERROR : WRITE_STATUS_OK, rv); |
70 connection_->OnPacketSent(result); | 81 callback_.Run(result); |
wtc
2014/06/20 21:40:50
BUG: I think we need to clear |callback_|. Our con
dmziegler
2014/06/23 18:31:24
Done.
| |
71 connection_->OnCanWrite(); | 82 blocked_writer_->OnCanWrite(); |
wtc
2014/06/20 21:40:50
Can you explain this change? It seems that callbac
dmziegler
2014/06/23 18:31:24
As explained in person, both lines are actually di
| |
72 } | 83 } |
73 | 84 |
74 } // namespace net | 85 } // namespace net |
OLD | NEW |