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

Side by Side Diff: remoting/protocol/quic_channel.cc

Issue 1493083002: Remove QUIC support from remoting host and client. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years 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
« no previous file with comments | « remoting/protocol/quic_channel.h ('k') | remoting/protocol/quic_channel_factory.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "remoting/protocol/quic_channel.h"
6
7 #include "base/callback_helpers.h"
8 #include "net/base/io_buffer.h"
9 #include "net/base/net_errors.h"
10
11 namespace remoting {
12 namespace protocol {
13
14 static const size_t kNamePrefixLength = 1;
15 static const size_t kMaxNameLength = 255;
16
17 QuicChannel::QuicChannel(net::QuicP2PStream* stream,
18 const base::Closure& on_destroyed_callback)
19 : stream_(stream), on_destroyed_callback_(on_destroyed_callback) {
20 DCHECK(stream_);
21 stream_->SetDelegate(this);
22 }
23
24 QuicChannel::~QuicChannel() {
25 // Don't call the read callback when destroying the stream.
26 read_callback_.Reset();
27
28 on_destroyed_callback_.Run();
29
30 // The callback must destroy the stream which must result in OnClose().
31 DCHECK(!stream_);
32 }
33
34 int QuicChannel::Read(const scoped_refptr<net::IOBuffer>& buffer,
35 int buffer_len,
36 const net::CompletionCallback& callback) {
37 DCHECK(read_callback_.is_null());
38
39 if (error_ != net::OK)
40 return error_;
41
42 if (data_received_.total_bytes() == 0) {
43 read_buffer_ = buffer;
44 read_buffer_size_ = buffer_len;
45 read_callback_ = callback;
46 return net::ERR_IO_PENDING;
47 }
48
49 int result = std::min(buffer_len, data_received_.total_bytes());
50 data_received_.CopyTo(buffer->data(), result);
51 data_received_.CropFront(result);
52 return result;
53 }
54
55 int QuicChannel::Write(const scoped_refptr<net::IOBuffer>& buffer,
56 int buffer_len,
57 const net::CompletionCallback& callback) {
58 if (error_ != net::OK)
59 return error_;
60
61 return stream_->Write(base::StringPiece(buffer->data(), buffer_len),
62 callback);
63 }
64
65 void QuicChannel::SetName(const std::string& name) {
66 DCHECK(name_.empty());
67
68 name_ = name;
69 }
70
71 void QuicChannel::OnDataReceived(const char* data, int length) {
72 if (read_callback_.is_null()) {
73 data_received_.AppendCopyOf(data, length);
74 return;
75 }
76
77 DCHECK_EQ(data_received_.total_bytes(), 0);
78 int bytes_to_read = std::min(length, read_buffer_size_);
79 memcpy(read_buffer_->data(), data, bytes_to_read);
80 read_buffer_ = nullptr;
81
82 // Copy leftover data to |data_received_|.
83 if (length > bytes_to_read)
84 data_received_.AppendCopyOf(data + bytes_to_read, length - bytes_to_read);
85
86 base::ResetAndReturn(&read_callback_).Run(bytes_to_read);
87 }
88
89 void QuicChannel::OnClose(net::QuicErrorCode error) {
90 error_ = (error == net::QUIC_NO_ERROR) ? net::ERR_CONNECTION_CLOSED
91 : net::ERR_QUIC_PROTOCOL_ERROR;
92 stream_ = nullptr;
93 if (!read_callback_.is_null()) {
94 base::ResetAndReturn(&read_callback_).Run(error_);
95 }
96 }
97
98 QuicClientChannel::QuicClientChannel(net::QuicP2PStream* stream,
99 const base::Closure& on_destroyed_callback,
100 const std::string& name)
101 : QuicChannel(stream, on_destroyed_callback) {
102 CHECK_LE(name.size(), kMaxNameLength);
103
104 SetName(name);
105
106 // Send the name to the host.
107 stream_->WriteHeader(
108 std::string(kNamePrefixLength, static_cast<char>(name.size())) + name);
109 }
110
111 QuicClientChannel::~QuicClientChannel() {}
112
113 QuicServerChannel::QuicServerChannel(
114 net::QuicP2PStream* stream,
115 const base::Closure& on_destroyed_callback)
116 : QuicChannel(stream, on_destroyed_callback) {}
117
118 void QuicServerChannel::ReceiveName(
119 const base::Closure& name_received_callback) {
120 name_received_callback_ = name_received_callback;
121
122 // First read 1 byte containing name length.
123 name_read_buffer_ = new net::DrainableIOBuffer(
124 new net::IOBuffer(kNamePrefixLength), kNamePrefixLength);
125 int result = Read(name_read_buffer_, kNamePrefixLength,
126 base::Bind(&QuicServerChannel::OnNameSizeReadResult,
127 base::Unretained(this)));
128 if (result != net::ERR_IO_PENDING)
129 OnNameSizeReadResult(result);
130 }
131
132 QuicServerChannel::~QuicServerChannel() {}
133
134 void QuicServerChannel::OnNameSizeReadResult(int result) {
135 if (result < 0) {
136 base::ResetAndReturn(&name_received_callback_).Run();
137 return;
138 }
139
140 DCHECK_EQ(result, static_cast<int>(kNamePrefixLength));
141 name_length_ = *reinterpret_cast<uint8_t*>(name_read_buffer_->data());
142 name_read_buffer_ =
143 new net::DrainableIOBuffer(new net::IOBuffer(name_length_), name_length_);
144 ReadNameLoop(0);
145 }
146
147 void QuicServerChannel::ReadNameLoop(int result) {
148 while (result >= 0 && name_read_buffer_->BytesRemaining() > 0) {
149 result = Read(name_read_buffer_, name_read_buffer_->BytesRemaining(),
150 base::Bind(&QuicServerChannel::OnNameReadResult,
151 base::Unretained(this)));
152 if (result >= 0) {
153 name_read_buffer_->DidConsume(result);
154 }
155 }
156
157 if (result < 0 && result != net::ERR_IO_PENDING) {
158 // Failed to read name for the stream.
159 base::ResetAndReturn(&name_received_callback_).Run();
160 return;
161 }
162
163 if (name_read_buffer_->BytesRemaining() == 0) {
164 name_read_buffer_->SetOffset(0);
165 SetName(std::string(name_read_buffer_->data(),
166 name_read_buffer_->data() + name_length_));
167 base::ResetAndReturn(&name_received_callback_).Run();
168 }
169 }
170
171 void QuicServerChannel::OnNameReadResult(int result) {
172 if (result > 0)
173 name_read_buffer_->DidConsume(result);
174
175 ReadNameLoop(result);
176 }
177
178 } // namespace protocol
179 } // namespace remoting
OLDNEW
« no previous file with comments | « remoting/protocol/quic_channel.h ('k') | remoting/protocol/quic_channel_factory.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698