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

Side by Side Diff: net/http/http_response_body_drainer_unittest.cc

Issue 1884943003: HttpStreamParser: Don't reuse sockets which receive unparsed data. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix drainer test ('True' means closed...) Created 4 years, 8 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 (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 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/http/http_response_body_drainer.h" 5 #include "net/http/http_response_body_drainer.h"
6 6
7 #include <stdint.h> 7 #include <stdint.h>
8 8
9 #include <cstring> 9 #include <cstring>
10 10
11 #include "base/bind.h" 11 #include "base/bind.h"
12 #include "base/compiler_specific.h" 12 #include "base/compiler_specific.h"
13 #include "base/location.h" 13 #include "base/location.h"
14 #include "base/macros.h" 14 #include "base/macros.h"
15 #include "base/memory/scoped_ptr.h"
15 #include "base/memory/weak_ptr.h" 16 #include "base/memory/weak_ptr.h"
16 #include "base/message_loop/message_loop.h" 17 #include "base/message_loop/message_loop.h"
17 #include "base/single_thread_task_runner.h" 18 #include "base/single_thread_task_runner.h"
18 #include "base/thread_task_runner_handle.h" 19 #include "base/thread_task_runner_handle.h"
19 #include "net/base/io_buffer.h" 20 #include "net/base/io_buffer.h"
20 #include "net/base/net_errors.h" 21 #include "net/base/net_errors.h"
21 #include "net/base/test_completion_callback.h" 22 #include "net/base/test_completion_callback.h"
22 #include "net/http/http_network_session.h" 23 #include "net/http/http_network_session.h"
24 #include "net/http/http_response_info.h"
23 #include "net/http/http_server_properties_impl.h" 25 #include "net/http/http_server_properties_impl.h"
24 #include "net/http/http_stream.h" 26 #include "net/http/http_stream.h"
25 #include "net/http/transport_security_state.h" 27 #include "net/http/transport_security_state.h"
26 #include "net/proxy/proxy_service.h" 28 #include "net/proxy/proxy_service.h"
27 #include "net/ssl/ssl_config_service_defaults.h" 29 #include "net/ssl/ssl_config_service_defaults.h"
28 #include "testing/gtest/include/gtest/gtest.h" 30 #include "testing/gtest/include/gtest/gtest.h"
29 31
30 namespace net { 32 namespace net {
31 33
32 namespace { 34 namespace {
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
72 public: 74 public:
73 MockHttpStream(CloseResultWaiter* result_waiter) 75 MockHttpStream(CloseResultWaiter* result_waiter)
74 : result_waiter_(result_waiter), 76 : result_waiter_(result_waiter),
75 buf_len_(0), 77 buf_len_(0),
76 closed_(false), 78 closed_(false),
77 stall_reads_forever_(false), 79 stall_reads_forever_(false),
78 num_chunks_(0), 80 num_chunks_(0),
79 is_sync_(false), 81 is_sync_(false),
80 is_last_chunk_zero_size_(false), 82 is_last_chunk_zero_size_(false),
81 is_complete_(false), 83 is_complete_(false),
84 can_reuse_connection_(true),
82 weak_factory_(this) {} 85 weak_factory_(this) {}
83 ~MockHttpStream() override {} 86 ~MockHttpStream() override {}
84 87
85 // HttpStream implementation. 88 // HttpStream implementation.
86 int InitializeStream(const HttpRequestInfo* request_info, 89 int InitializeStream(const HttpRequestInfo* request_info,
87 RequestPriority priority, 90 RequestPriority priority,
88 const BoundNetLog& net_log, 91 const BoundNetLog& net_log,
89 const CompletionCallback& callback) override { 92 const CompletionCallback& callback) override {
90 return ERR_UNEXPECTED; 93 return ERR_UNEXPECTED;
91 } 94 }
92 int SendRequest(const HttpRequestHeaders& request_headers, 95 int SendRequest(const HttpRequestHeaders& request_headers,
93 HttpResponseInfo* response, 96 HttpResponseInfo* response,
94 const CompletionCallback& callback) override { 97 const CompletionCallback& callback) override {
95 return ERR_UNEXPECTED; 98 return ERR_UNEXPECTED;
96 } 99 }
97 UploadProgress GetUploadProgress() const override { return UploadProgress(); } 100 UploadProgress GetUploadProgress() const override { return UploadProgress(); }
98 int ReadResponseHeaders(const CompletionCallback& callback) override { 101 int ReadResponseHeaders(const CompletionCallback& callback) override {
99 return ERR_UNEXPECTED; 102 return ERR_UNEXPECTED;
100 } 103 }
101 104
102 bool IsConnectionReused() const override { return false; } 105 bool IsConnectionReused() const override { return false; }
103 void SetConnectionReused() override {} 106 void SetConnectionReused() override {}
104 bool CanReuseConnection() const override { return false; } 107 bool CanReuseConnection() const override { return can_reuse_connection_; }
105 int64_t GetTotalReceivedBytes() const override { return 0; } 108 int64_t GetTotalReceivedBytes() const override { return 0; }
106 int64_t GetTotalSentBytes() const override { return 0; } 109 int64_t GetTotalSentBytes() const override { return 0; }
107 void GetSSLInfo(SSLInfo* ssl_info) override {} 110 void GetSSLInfo(SSLInfo* ssl_info) override {}
108 void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {} 111 void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
109 bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; } 112 bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; }
110 Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key, 113 Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key,
111 std::vector<uint8_t>* out) override { 114 std::vector<uint8_t>* out) override {
112 ADD_FAILURE(); 115 ADD_FAILURE();
113 return ERR_NOT_IMPLEMENTED; 116 return ERR_NOT_IMPLEMENTED;
114 } 117 }
115 118
116 // Mocked API 119 // Mocked API
117 int ReadResponseBody(IOBuffer* buf, 120 int ReadResponseBody(IOBuffer* buf,
118 int buf_len, 121 int buf_len,
119 const CompletionCallback& callback) override; 122 const CompletionCallback& callback) override;
120 void Close(bool not_reusable) override { 123 void Close(bool not_reusable) override {
121 CHECK(!closed_); 124 CHECK(!closed_);
122 closed_ = true; 125 closed_ = true;
123 result_waiter_->set_result(not_reusable); 126 result_waiter_->set_result(not_reusable);
124 } 127 }
125 128
126 HttpStream* RenewStreamForAuth() override { return NULL; } 129 HttpStream* RenewStreamForAuth() override { return NULL; }
127 130
128 bool IsResponseBodyComplete() const override { return is_complete_; } 131 bool IsResponseBodyComplete() const override { return is_complete_; }
129 132
130 bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override { 133 bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
131 return false; 134 return false;
132 } 135 }
133 136
134 void Drain(HttpNetworkSession*) override {} 137 void Drain(HttpNetworkSession* session,
138 scoped_ptr<HttpResponseInfo> response_info) override {}
135 139
136 void PopulateNetErrorDetails(NetErrorDetails* details) override { return; } 140 void PopulateNetErrorDetails(NetErrorDetails* details) override { return; }
137 141
138 void SetPriority(RequestPriority priority) override {} 142 void SetPriority(RequestPriority priority) override {}
139 143
140 // Methods to tweak/observer mock behavior: 144 // Methods to tweak/observer mock behavior:
141 void set_stall_reads_forever() { stall_reads_forever_ = true; } 145 void set_stall_reads_forever() { stall_reads_forever_ = true; }
142 146
143 void set_num_chunks(int num_chunks) { num_chunks_ = num_chunks; } 147 void set_num_chunks(int num_chunks) { num_chunks_ = num_chunks; }
144 148
145 void set_sync() { is_sync_ = true; } 149 void set_sync() { is_sync_ = true; }
146 150
147 void set_is_last_chunk_zero_size() { is_last_chunk_zero_size_ = true; } 151 void set_is_last_chunk_zero_size() { is_last_chunk_zero_size_ = true; }
148 152
153 // Sets result value of CanReuseConnection. Defaults to true.
154 void set_can_reuse_connection(bool can_reuse_connection) {
155 can_reuse_connection_ = can_reuse_connection;
156 }
157
149 private: 158 private:
150 int ReadResponseBodyImpl(IOBuffer* buf, int buf_len); 159 int ReadResponseBodyImpl(IOBuffer* buf, int buf_len);
151 void CompleteRead(); 160 void CompleteRead();
152 161
153 bool closed() const { return closed_; } 162 bool closed() const { return closed_; }
154 163
155 CloseResultWaiter* const result_waiter_; 164 CloseResultWaiter* const result_waiter_;
156 scoped_refptr<IOBuffer> user_buf_; 165 scoped_refptr<IOBuffer> user_buf_;
157 CompletionCallback callback_; 166 CompletionCallback callback_;
158 int buf_len_; 167 int buf_len_;
159 bool closed_; 168 bool closed_;
160 bool stall_reads_forever_; 169 bool stall_reads_forever_;
161 int num_chunks_; 170 int num_chunks_;
162 bool is_sync_; 171 bool is_sync_;
163 bool is_last_chunk_zero_size_; 172 bool is_last_chunk_zero_size_;
164 bool is_complete_; 173 bool is_complete_;
174 bool can_reuse_connection_;
175
165 base::WeakPtrFactory<MockHttpStream> weak_factory_; 176 base::WeakPtrFactory<MockHttpStream> weak_factory_;
177
178 DISALLOW_COPY_AND_ASSIGN(MockHttpStream);
166 }; 179 };
167 180
168 int MockHttpStream::ReadResponseBody(IOBuffer* buf, 181 int MockHttpStream::ReadResponseBody(IOBuffer* buf,
169 int buf_len, 182 int buf_len,
170 const CompletionCallback& callback) { 183 const CompletionCallback& callback) {
171 CHECK(!callback.is_null()); 184 CHECK(!callback.is_null());
172 CHECK(callback_.is_null()); 185 CHECK(callback_.is_null());
173 CHECK(buf); 186 CHECK(buf);
174 187
175 if (stall_reads_forever_) 188 if (stall_reads_forever_)
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
216 229
217 class HttpResponseBodyDrainerTest : public testing::Test { 230 class HttpResponseBodyDrainerTest : public testing::Test {
218 protected: 231 protected:
219 HttpResponseBodyDrainerTest() 232 HttpResponseBodyDrainerTest()
220 : proxy_service_(ProxyService::CreateDirect()), 233 : proxy_service_(ProxyService::CreateDirect()),
221 ssl_config_service_(new SSLConfigServiceDefaults), 234 ssl_config_service_(new SSLConfigServiceDefaults),
222 http_server_properties_(new HttpServerPropertiesImpl()), 235 http_server_properties_(new HttpServerPropertiesImpl()),
223 transport_security_state_(new TransportSecurityState()), 236 transport_security_state_(new TransportSecurityState()),
224 session_(CreateNetworkSession()), 237 session_(CreateNetworkSession()),
225 mock_stream_(new MockHttpStream(&result_waiter_)), 238 mock_stream_(new MockHttpStream(&result_waiter_)),
226 drainer_(new HttpResponseBodyDrainer(mock_stream_)) {} 239 drainer_(new HttpResponseBodyDrainer(
240 mock_stream_,
241 make_scoped_ptr(new HttpResponseInfo()))) {}
227 242
228 ~HttpResponseBodyDrainerTest() override {} 243 ~HttpResponseBodyDrainerTest() override {}
229 244
230 HttpNetworkSession* CreateNetworkSession() const { 245 HttpNetworkSession* CreateNetworkSession() const {
231 HttpNetworkSession::Params params; 246 HttpNetworkSession::Params params;
232 params.proxy_service = proxy_service_.get(); 247 params.proxy_service = proxy_service_.get();
233 params.ssl_config_service = ssl_config_service_.get(); 248 params.ssl_config_service = ssl_config_service_.get();
234 params.http_server_properties = http_server_properties_->GetWeakPtr(); 249 params.http_server_properties = http_server_properties_->GetWeakPtr();
235 params.transport_security_state = transport_security_state_.get(); 250 params.transport_security_state = transport_security_state_.get();
236 return new HttpNetworkSession(params); 251 return new HttpNetworkSession(params);
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
308 TEST_F(HttpResponseBodyDrainerTest, DrainBodyTooLarge) { 323 TEST_F(HttpResponseBodyDrainerTest, DrainBodyTooLarge) {
309 int too_many_chunks = 324 int too_many_chunks =
310 HttpResponseBodyDrainer::kDrainBodyBufferSize / kMagicChunkSize; 325 HttpResponseBodyDrainer::kDrainBodyBufferSize / kMagicChunkSize;
311 too_many_chunks += 1; // Now it's too large. 326 too_many_chunks += 1; // Now it's too large.
312 327
313 mock_stream_->set_num_chunks(too_many_chunks); 328 mock_stream_->set_num_chunks(too_many_chunks);
314 drainer_->Start(session_.get()); 329 drainer_->Start(session_.get());
315 EXPECT_TRUE(result_waiter_.WaitForResult()); 330 EXPECT_TRUE(result_waiter_.WaitForResult());
316 } 331 }
317 332
333 TEST_F(HttpResponseBodyDrainerTest, DrainBodyCantReuse) {
334 mock_stream_->set_num_chunks(1);
335 mock_stream_->set_can_reuse_connection(false);
336 drainer_->Start(session_.get());
337 EXPECT_TRUE(result_waiter_.WaitForResult());
338 }
339
318 } // namespace 340 } // namespace
319 341
320 } // namespace net 342 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698