OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "content/browser/loader/async_resource_handler.h" | 5 #include "content/browser/loader/async_resource_handler.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 #include <memory> | 9 #include <memory> |
10 #include <string> | 10 #include <string> |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
57 namespace { | 57 namespace { |
58 | 58 |
59 std::string GenerateHeader(size_t response_data_size) { | 59 std::string GenerateHeader(size_t response_data_size) { |
60 return base::StringPrintf( | 60 return base::StringPrintf( |
61 "HTTP/1.1 200 OK\n" | 61 "HTTP/1.1 200 OK\n" |
62 "Content-type: text/html\n" | 62 "Content-type: text/html\n" |
63 "Content-Length: %" PRIuS "\n", | 63 "Content-Length: %" PRIuS "\n", |
64 response_data_size); | 64 response_data_size); |
65 } | 65 } |
66 | 66 |
| 67 int64_t TotalReceivedBytes(size_t response_data_size) { |
| 68 return response_data_size + GenerateHeader(response_data_size).size(); |
| 69 } |
| 70 |
67 std::string GenerateData(size_t response_data_size) { | 71 std::string GenerateData(size_t response_data_size) { |
68 return std::string(response_data_size, 'a'); | 72 return std::string(response_data_size, 'a'); |
69 } | 73 } |
70 | 74 |
71 class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler { | 75 class TestProtocolHandler : public net::URLRequestJobFactory::ProtocolHandler { |
72 public: | 76 public: |
73 TestProtocolHandler(size_t response_data_size) | 77 TestProtocolHandler(size_t response_data_size) |
74 : response_data_size_(response_data_size) {} | 78 : response_data_size_(response_data_size) {} |
75 | 79 |
76 net::URLRequestJob* MaybeCreateJob( | 80 net::URLRequestJob* MaybeCreateJob( |
(...skipping 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
241 std::unique_ptr<base::RunLoop> finish_waiter_; | 245 std::unique_ptr<base::RunLoop> finish_waiter_; |
242 }; | 246 }; |
243 | 247 |
244 TEST_F(AsyncResourceHandlerTest, Construct) { | 248 TEST_F(AsyncResourceHandlerTest, Construct) { |
245 CreateRequestWithResponseDataSize(1); | 249 CreateRequestWithResponseDataSize(1); |
246 } | 250 } |
247 | 251 |
248 TEST_F(AsyncResourceHandlerTest, OneChunkLengths) { | 252 TEST_F(AsyncResourceHandlerTest, OneChunkLengths) { |
249 // Larger than kInlinedLeadingChunkSize and smaller than | 253 // Larger than kInlinedLeadingChunkSize and smaller than |
250 // kMaxAllocationSize. | 254 // kMaxAllocationSize. |
251 StartRequestAndWaitWithResponseDataSize(4096); | 255 constexpr auto kDataSize = 4096; |
| 256 StartRequestAndWaitWithResponseDataSize(kDataSize); |
252 const auto& messages = filter_->messages(); | 257 const auto& messages = filter_->messages(); |
253 ASSERT_EQ(4u, messages.size()); | 258 ASSERT_EQ(4u, messages.size()); |
254 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2]->type()); | 259 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2]->type()); |
255 ResourceMsg_DataReceived::Param params; | 260 ResourceMsg_DataReceived::Param params; |
256 ResourceMsg_DataReceived::Read(messages[2].get(), ¶ms); | 261 ResourceMsg_DataReceived::Read(messages[2].get(), ¶ms); |
257 | 262 |
258 int encoded_data_length = std::get<3>(params); | 263 int encoded_data_length = std::get<3>(params); |
259 EXPECT_EQ(4096, encoded_data_length); | 264 EXPECT_EQ(kDataSize, encoded_data_length); |
260 int encoded_body_length = std::get<4>(params); | 265 int encoded_body_length = std::get<4>(params); |
261 EXPECT_EQ(4096, encoded_body_length); | 266 EXPECT_EQ(kDataSize, encoded_body_length); |
| 267 |
| 268 ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[3]->type()); |
| 269 ResourceMsg_RequestComplete::Param completion_params; |
| 270 ResourceMsg_RequestComplete::Read(messages[3].get(), &completion_params); |
| 271 ResourceRequestCompletionStatus completion_status = |
| 272 std::get<1>(completion_params); |
| 273 |
| 274 EXPECT_EQ(TotalReceivedBytes(kDataSize), |
| 275 completion_status.encoded_data_length); |
| 276 EXPECT_EQ(kDataSize, completion_status.encoded_body_length); |
262 } | 277 } |
263 | 278 |
264 TEST_F(AsyncResourceHandlerTest, InlinedChunkLengths) { | 279 TEST_F(AsyncResourceHandlerTest, InlinedChunkLengths) { |
265 // TODO(ricea): Remove this Feature-enabling code once the feature is on by | 280 // TODO(ricea): Remove this Feature-enabling code once the feature is on by |
266 // default. | 281 // default. |
267 base::test::ScopedFeatureList scoped_feature_list; | 282 base::test::ScopedFeatureList scoped_feature_list; |
268 scoped_feature_list.InitAndEnableFeature( | 283 scoped_feature_list.InitAndEnableFeature( |
269 features::kOptimizeLoadingIPCForSmallResources); | 284 features::kOptimizeLoadingIPCForSmallResources); |
270 | 285 |
271 // Smaller than kInlinedLeadingChunkSize. | 286 // Smaller than kInlinedLeadingChunkSize. |
272 StartRequestAndWaitWithResponseDataSize(8); | 287 constexpr auto kDataSize = 8; |
| 288 StartRequestAndWaitWithResponseDataSize(kDataSize); |
273 const auto& messages = filter_->messages(); | 289 const auto& messages = filter_->messages(); |
274 ASSERT_EQ(3u, messages.size()); | 290 ASSERT_EQ(3u, messages.size()); |
275 ASSERT_EQ(ResourceMsg_InlinedDataChunkReceived::ID, messages[1]->type()); | 291 ASSERT_EQ(ResourceMsg_InlinedDataChunkReceived::ID, messages[1]->type()); |
276 ResourceMsg_InlinedDataChunkReceived::Param params; | 292 ResourceMsg_InlinedDataChunkReceived::Param params; |
277 ResourceMsg_InlinedDataChunkReceived::Read(messages[1].get(), ¶ms); | 293 ResourceMsg_InlinedDataChunkReceived::Read(messages[1].get(), ¶ms); |
278 | 294 |
279 int encoded_data_length = std::get<2>(params); | 295 int encoded_data_length = std::get<2>(params); |
280 EXPECT_EQ(8, encoded_data_length); | 296 EXPECT_EQ(kDataSize, encoded_data_length); |
281 int encoded_body_length = std::get<3>(params); | 297 int encoded_body_length = std::get<3>(params); |
282 EXPECT_EQ(8, encoded_body_length); | 298 EXPECT_EQ(kDataSize, encoded_body_length); |
| 299 |
| 300 ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[2]->type()); |
| 301 ResourceMsg_RequestComplete::Param completion_params; |
| 302 ResourceMsg_RequestComplete::Read(messages[2].get(), &completion_params); |
| 303 ResourceRequestCompletionStatus completion_status = |
| 304 std::get<1>(completion_params); |
| 305 |
| 306 EXPECT_EQ(TotalReceivedBytes(kDataSize), |
| 307 completion_status.encoded_data_length); |
| 308 EXPECT_EQ(kDataSize, completion_status.encoded_body_length); |
283 } | 309 } |
284 | 310 |
285 TEST_F(AsyncResourceHandlerTest, TwoChunksLengths) { | 311 TEST_F(AsyncResourceHandlerTest, TwoChunksLengths) { |
286 // Larger than kMaxAllocationSize. | 312 // Larger than kMaxAllocationSize. |
287 StartRequestAndWaitWithResponseDataSize(64*1024); | 313 constexpr auto kDataSize = 64 * 1024; |
| 314 StartRequestAndWaitWithResponseDataSize(kDataSize); |
288 const auto& messages = filter_->messages(); | 315 const auto& messages = filter_->messages(); |
289 ASSERT_EQ(5u, messages.size()); | 316 ASSERT_EQ(5u, messages.size()); |
290 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2]->type()); | 317 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2]->type()); |
291 ResourceMsg_DataReceived::Param params; | 318 ResourceMsg_DataReceived::Param params; |
292 ResourceMsg_DataReceived::Read(messages[2].get(), ¶ms); | 319 ResourceMsg_DataReceived::Read(messages[2].get(), ¶ms); |
293 | 320 |
294 int encoded_data_length = std::get<3>(params); | 321 int encoded_data_length = std::get<3>(params); |
295 EXPECT_EQ(32768, encoded_data_length); | 322 EXPECT_EQ(32768, encoded_data_length); |
296 int encoded_body_length = std::get<4>(params); | 323 int encoded_body_length = std::get<4>(params); |
297 EXPECT_EQ(32768, encoded_body_length); | 324 EXPECT_EQ(32768, encoded_body_length); |
298 | 325 |
299 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[3]->type()); | 326 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[3]->type()); |
300 ResourceMsg_DataReceived::Read(messages[3].get(), ¶ms); | 327 ResourceMsg_DataReceived::Read(messages[3].get(), ¶ms); |
301 | 328 |
302 encoded_data_length = std::get<3>(params); | 329 encoded_data_length = std::get<3>(params); |
303 EXPECT_EQ(32768, encoded_data_length); | 330 EXPECT_EQ(32768, encoded_data_length); |
304 encoded_body_length = std::get<4>(params); | 331 encoded_body_length = std::get<4>(params); |
305 EXPECT_EQ(32768, encoded_body_length); | 332 EXPECT_EQ(32768, encoded_body_length); |
| 333 |
| 334 ASSERT_EQ(ResourceMsg_RequestComplete::ID, messages[4]->type()); |
| 335 ResourceMsg_RequestComplete::Param completion_params; |
| 336 ResourceMsg_RequestComplete::Read(messages[4].get(), &completion_params); |
| 337 ResourceRequestCompletionStatus completion_status = |
| 338 std::get<1>(completion_params); |
| 339 EXPECT_EQ(TotalReceivedBytes(kDataSize), |
| 340 completion_status.encoded_data_length); |
| 341 EXPECT_EQ(kDataSize, completion_status.encoded_body_length); |
306 } | 342 } |
307 | 343 |
308 } // namespace | 344 } // namespace |
309 | 345 |
310 } // namespace content | 346 } // namespace content |
OLD | NEW |