Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(61)

Side by Side Diff: net/quic/quic_server_packet_writer.cc

Issue 340433002: Port QuicServer to Chrome network stack (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Address further comments Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698