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/url_request/url_request_simple_job.h" | 5 #include "net/url_request/url_request_simple_job.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/bind_helpers.h" | 9 #include "base/bind_helpers.h" |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
81 ~CancelAfterFirstReadURLRequestDelegate() override {} | 81 ~CancelAfterFirstReadURLRequestDelegate() override {} |
82 | 82 |
83 void OnResponseStarted(URLRequest* request, int net_error) override { | 83 void OnResponseStarted(URLRequest* request, int net_error) override { |
84 DCHECK_NE(ERR_IO_PENDING, net_error); | 84 DCHECK_NE(ERR_IO_PENDING, net_error); |
85 // net::TestDelegate will start the first read. | 85 // net::TestDelegate will start the first read. |
86 TestDelegate::OnResponseStarted(request, net_error); | 86 TestDelegate::OnResponseStarted(request, net_error); |
87 request->Cancel(); | 87 request->Cancel(); |
88 run_loop_->Quit(); | 88 run_loop_->Quit(); |
89 } | 89 } |
90 | 90 |
91 void OnReadCompleted(URLRequest* request, int bytes_read) override { | |
92 // Read should have been cancelled. | |
93 EXPECT_EQ(ERR_ABORTED, bytes_read); | |
94 } | |
95 | |
96 void WaitUntilHeadersReceived() const { run_loop_->Run(); } | 91 void WaitUntilHeadersReceived() const { run_loop_->Run(); } |
97 | 92 |
98 private: | 93 private: |
99 std::unique_ptr<base::RunLoop> run_loop_; | 94 std::unique_ptr<base::RunLoop> run_loop_; |
100 | 95 |
101 DISALLOW_COPY_AND_ASSIGN(CancelAfterFirstReadURLRequestDelegate); | 96 DISALLOW_COPY_AND_ASSIGN(CancelAfterFirstReadURLRequestDelegate); |
102 }; | 97 }; |
103 | 98 |
104 class SimpleJobProtocolHandler : | 99 class SimpleJobProtocolHandler : |
105 public URLRequestJobFactory::ProtocolHandler { | 100 public URLRequestJobFactory::ProtocolHandler { |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
156 TestURLRequestContext context_; | 151 TestURLRequestContext context_; |
157 URLRequestJobFactoryImpl job_factory_; | 152 URLRequestJobFactoryImpl job_factory_; |
158 TestDelegate delegate_; | 153 TestDelegate delegate_; |
159 std::unique_ptr<URLRequest> request_; | 154 std::unique_ptr<URLRequest> request_; |
160 }; | 155 }; |
161 | 156 |
162 } // namespace | 157 } // namespace |
163 | 158 |
164 TEST_F(URLRequestSimpleJobTest, SimpleRequest) { | 159 TEST_F(URLRequestSimpleJobTest, SimpleRequest) { |
165 StartRequest(NULL); | 160 StartRequest(NULL); |
166 ASSERT_TRUE(request_->status().is_success()); | 161 EXPECT_THAT(delegate_.request_status(), IsOk()); |
167 EXPECT_EQ(kTestData, delegate_.data_received()); | 162 EXPECT_EQ(kTestData, delegate_.data_received()); |
168 } | 163 } |
169 | 164 |
170 TEST_F(URLRequestSimpleJobTest, RangeRequest) { | 165 TEST_F(URLRequestSimpleJobTest, RangeRequest) { |
171 const std::string kExpectedBody = std::string( | 166 const std::string kExpectedBody = std::string( |
172 kTestData + kRangeFirstPosition, kTestData + kRangeLastPosition + 1); | 167 kTestData + kRangeFirstPosition, kTestData + kRangeLastPosition + 1); |
173 HttpRequestHeaders headers; | 168 HttpRequestHeaders headers; |
174 headers.SetHeader( | 169 headers.SetHeader( |
175 HttpRequestHeaders::kRange, | 170 HttpRequestHeaders::kRange, |
176 HttpByteRange::Bounded(kRangeFirstPosition, kRangeLastPosition) | 171 HttpByteRange::Bounded(kRangeFirstPosition, kRangeLastPosition) |
177 .GetHeaderValue()); | 172 .GetHeaderValue()); |
178 | 173 |
179 StartRequest(&headers); | 174 StartRequest(&headers); |
180 | 175 |
181 ASSERT_TRUE(request_->status().is_success()); | 176 EXPECT_THAT(delegate_.request_status(), IsOk()); |
182 EXPECT_EQ(kExpectedBody, delegate_.data_received()); | 177 EXPECT_EQ(kExpectedBody, delegate_.data_received()); |
183 } | 178 } |
184 | 179 |
185 TEST_F(URLRequestSimpleJobTest, MultipleRangeRequest) { | 180 TEST_F(URLRequestSimpleJobTest, MultipleRangeRequest) { |
186 HttpRequestHeaders headers; | 181 HttpRequestHeaders headers; |
187 int middle_pos = (kRangeFirstPosition + kRangeLastPosition)/2; | 182 int middle_pos = (kRangeFirstPosition + kRangeLastPosition)/2; |
188 std::string range = base::StringPrintf("bytes=%d-%d,%d-%d", | 183 std::string range = base::StringPrintf("bytes=%d-%d,%d-%d", |
189 kRangeFirstPosition, | 184 kRangeFirstPosition, |
190 middle_pos, | 185 middle_pos, |
191 middle_pos + 1, | 186 middle_pos + 1, |
192 kRangeLastPosition); | 187 kRangeLastPosition); |
193 headers.SetHeader(HttpRequestHeaders::kRange, range); | 188 headers.SetHeader(HttpRequestHeaders::kRange, range); |
194 | 189 |
195 StartRequest(&headers); | 190 StartRequest(&headers); |
196 | 191 |
197 EXPECT_TRUE(delegate_.request_failed()); | 192 EXPECT_TRUE(delegate_.request_failed()); |
198 EXPECT_THAT(request_->status().error(), | 193 EXPECT_EQ(ERR_REQUEST_RANGE_NOT_SATISFIABLE, delegate_.request_status()); |
199 IsError(ERR_REQUEST_RANGE_NOT_SATISFIABLE)); | |
200 } | 194 } |
201 | 195 |
202 TEST_F(URLRequestSimpleJobTest, InvalidRangeRequest) { | 196 TEST_F(URLRequestSimpleJobTest, InvalidRangeRequest) { |
203 HttpRequestHeaders headers; | 197 HttpRequestHeaders headers; |
204 std::string range = base::StringPrintf( | 198 std::string range = base::StringPrintf( |
205 "bytes=%d-%d", kRangeLastPosition, kRangeFirstPosition); | 199 "bytes=%d-%d", kRangeLastPosition, kRangeFirstPosition); |
206 headers.SetHeader(HttpRequestHeaders::kRange, range); | 200 headers.SetHeader(HttpRequestHeaders::kRange, range); |
207 | 201 |
208 StartRequest(&headers); | 202 StartRequest(&headers); |
209 | 203 |
210 ASSERT_TRUE(request_->status().is_success()); | 204 EXPECT_THAT(delegate_.request_status(), IsOk()); |
211 EXPECT_EQ(kTestData, delegate_.data_received()); | 205 EXPECT_EQ(kTestData, delegate_.data_received()); |
212 } | 206 } |
213 | 207 |
214 TEST_F(URLRequestSimpleJobTest, EmptyDataRequest) { | 208 TEST_F(URLRequestSimpleJobTest, EmptyDataRequest) { |
215 request_ = | 209 request_ = |
216 context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY, &delegate_); | 210 context_.CreateRequest(GURL("data:empty"), DEFAULT_PRIORITY, &delegate_); |
217 StartRequest(nullptr); | 211 StartRequest(nullptr); |
218 ASSERT_TRUE(request_->status().is_success()); | 212 EXPECT_THAT(delegate_.request_status(), IsOk()); |
219 EXPECT_EQ("", delegate_.data_received()); | 213 EXPECT_EQ("", delegate_.data_received()); |
220 } | 214 } |
221 | 215 |
222 TEST_F(URLRequestSimpleJobTest, CancelBeforeResponseStarts) { | 216 TEST_F(URLRequestSimpleJobTest, CancelBeforeResponseStarts) { |
223 request_ = | 217 request_ = |
224 context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY, &delegate_); | 218 context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY, &delegate_); |
225 request_->Start(); | 219 request_->Start(); |
226 request_->Cancel(); | 220 request_->Cancel(); |
227 | 221 |
228 base::RunLoop().RunUntilIdle(); | 222 base::RunLoop().RunUntilIdle(); |
229 EXPECT_EQ(URLRequestStatus::CANCELED, request_->status().status()); | 223 EXPECT_THAT(delegate_.request_status(), IsError(ERR_ABORTED)); |
230 EXPECT_EQ(1, delegate_.response_started_count()); | 224 EXPECT_EQ(1, delegate_.response_started_count()); |
231 } | 225 } |
232 | 226 |
233 TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) { | 227 TEST_F(URLRequestSimpleJobTest, CancelAfterFirstReadStarted) { |
234 CancelAfterFirstReadURLRequestDelegate cancel_delegate; | 228 CancelAfterFirstReadURLRequestDelegate cancel_delegate; |
235 request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY, | 229 request_ = context_.CreateRequest(GURL("data:cancel"), DEFAULT_PRIORITY, |
236 &cancel_delegate); | 230 &cancel_delegate); |
237 request_->Start(); | 231 request_->Start(); |
238 cancel_delegate.WaitUntilHeadersReceived(); | 232 cancel_delegate.WaitUntilHeadersReceived(); |
239 | 233 |
240 // Feed a dummy task to the SequencedTaskRunner to make sure that the | 234 // Feed a dummy task to the SequencedTaskRunner to make sure that the |
241 // callbacks which are invoked in ReadRawData have completed safely. | 235 // callbacks which are invoked in ReadRawData have completed safely. |
242 base::RunLoop run_loop; | 236 base::RunLoop run_loop; |
243 EXPECT_TRUE(task_runner_->PostTaskAndReply( | 237 EXPECT_TRUE(task_runner_->PostTaskAndReply( |
244 FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure())); | 238 FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure())); |
245 run_loop.Run(); | 239 run_loop.Run(); |
246 | 240 |
247 EXPECT_EQ(URLRequestStatus::CANCELED, request_->status().status()); | 241 EXPECT_THAT(cancel_delegate.request_status(), IsError(ERR_ABORTED)); |
248 EXPECT_EQ(1, cancel_delegate.response_started_count()); | 242 EXPECT_EQ(1, cancel_delegate.response_started_count()); |
249 EXPECT_EQ("", cancel_delegate.data_received()); | 243 EXPECT_EQ("", cancel_delegate.data_received()); |
250 // Destroy the request so it doesn't outlive its delegate. | 244 // Destroy the request so it doesn't outlive its delegate. |
251 request_.reset(); | 245 request_.reset(); |
252 } | 246 } |
253 | 247 |
254 } // namespace net | 248 } // namespace net |
OLD | NEW |