OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 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 "components/data_reduction_proxy/content/browser/content_lofi_decider.h
" | 5 #include "components/data_reduction_proxy/content/browser/content_lofi_decider.h
" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <memory> | 8 #include <memory> |
9 #include <string> | 9 #include <string> |
10 #include <utility> | 10 #include <utility> |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
196 const net::HttpRequestHeaders& headers) { | 196 const net::HttpRequestHeaders& headers) { |
197 EXPECT_EQ(expected_compressed_video_used, | 197 EXPECT_EQ(expected_compressed_video_used, |
198 headers.HasHeader(chrome_proxy_accept_transform_header())); | 198 headers.HasHeader(chrome_proxy_accept_transform_header())); |
199 std::string header_value; | 199 std::string header_value; |
200 headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value); | 200 headers.GetHeader(chrome_proxy_accept_transform_header(), &header_value); |
201 EXPECT_EQ( | 201 EXPECT_EQ( |
202 expected_compressed_video_used, | 202 expected_compressed_video_used, |
203 header_value.find(compressed_video_directive()) != std::string::npos); | 203 header_value.find(compressed_video_directive()) != std::string::npos); |
204 } | 204 } |
205 | 205 |
206 static void VerifyLitePageIgnoreBlacklistHeader( | |
207 bool expected_blacklist_directive_added, | |
208 const net::HttpRequestHeaders& headers) { | |
209 EXPECT_TRUE(headers.HasHeader(chrome_proxy_header())); | |
210 std::string header_value; | |
211 headers.GetHeader(chrome_proxy_header(), &header_value); | |
212 EXPECT_EQ(expected_blacklist_directive_added, | |
213 header_value.find( | |
214 chrome_proxy_lite_page_ignore_blacklist_directive()) != | |
215 std::string::npos); | |
216 } | |
217 | |
218 protected: | 206 protected: |
219 base::MessageLoopForIO message_loop_; | 207 base::MessageLoopForIO message_loop_; |
220 net::TestURLRequestContext context_; | 208 net::TestURLRequestContext context_; |
221 net::TestDelegate delegate_; | 209 net::TestDelegate delegate_; |
222 std::unique_ptr<DataReductionProxyTestContext> test_context_; | 210 std::unique_ptr<DataReductionProxyTestContext> test_context_; |
223 std::unique_ptr<DataReductionProxyNetworkDelegate> | 211 std::unique_ptr<DataReductionProxyNetworkDelegate> |
224 data_reduction_proxy_network_delegate_; | 212 data_reduction_proxy_network_delegate_; |
225 }; | 213 }; |
226 | 214 |
227 TEST_F(ContentLoFiDeciderTest, LoFiFlags) { | 215 TEST_F(ContentLoFiDeciderTest, LoFiFlags) { |
(...skipping 23 matching lines...) Expand all Loading... |
251 command_line->InitFromArgv(command_line->argv()); | 239 command_line->InitFromArgv(command_line->argv()); |
252 if (tests[i].is_using_lite_page) { | 240 if (tests[i].is_using_lite_page) { |
253 command_line->AppendSwitch(switches::kEnableDataReductionProxyLitePage); | 241 command_line->AppendSwitch(switches::kEnableDataReductionProxyLitePage); |
254 } | 242 } |
255 | 243 |
256 // No flags or field trials. The Lo-Fi header should not be added. | 244 // No flags or field trials. The Lo-Fi header should not be added. |
257 net::HttpRequestHeaders headers; | 245 net::HttpRequestHeaders headers; |
258 NotifyBeforeSendHeaders(&headers, request.get(), true); | 246 NotifyBeforeSendHeaders(&headers, request.get(), true); |
259 VerifyLoFiHeader(false, false, headers); | 247 VerifyLoFiHeader(false, false, headers); |
260 VerifyLitePageHeader(false, false, headers); | 248 VerifyLitePageHeader(false, false, headers); |
261 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
262 | |
263 // The Lo-Fi flag is "always-on", Lo-Fi is being used, and it's a main frame | 249 // The Lo-Fi flag is "always-on", Lo-Fi is being used, and it's a main frame |
264 // request. Lo-Fi or lite page header should be added. | 250 // request. Lo-Fi or lite page header should be added. |
265 command_line->AppendSwitchASCII( | 251 command_line->AppendSwitchASCII( |
266 switches::kDataReductionProxyLoFi, | 252 switches::kDataReductionProxyLoFi, |
267 switches::kDataReductionProxyLoFiValueAlwaysOn); | 253 switches::kDataReductionProxyLoFiValueAlwaysOn); |
268 headers.Clear(); | 254 headers.Clear(); |
269 NotifyBeforeSendHeaders(&headers, request.get(), true); | 255 NotifyBeforeSendHeaders(&headers, request.get(), true); |
270 VerifyLoFiHeader(!tests[i].is_main_frame && !tests[i].is_using_lite_page, | 256 VerifyLoFiHeader(!tests[i].is_main_frame && !tests[i].is_using_lite_page, |
271 !tests[i].is_main_frame && !tests[i].is_using_lofi && | 257 !tests[i].is_main_frame && !tests[i].is_using_lofi && |
272 !tests[i].is_using_lite_page, | 258 !tests[i].is_using_lite_page, |
273 headers); | 259 headers); |
274 VerifyLitePageHeader(tests[i].is_using_lite_page && tests[i].is_main_frame, | 260 VerifyLitePageHeader(tests[i].is_using_lite_page && tests[i].is_main_frame, |
275 false, headers); | 261 false, headers); |
276 VerifyLitePageIgnoreBlacklistHeader( | |
277 tests[i].is_using_lite_page && tests[i].is_main_frame, headers); | |
278 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); | 262 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); |
279 // |lofi_requested| should be set to false when Lo-Fi is enabled using | 263 // |lofi_requested| should be set to false when Lo-Fi is enabled using |
280 // flags. | 264 // flags. |
281 EXPECT_FALSE(data->lofi_requested()); | 265 EXPECT_FALSE(data->lofi_requested()); |
282 | 266 |
283 // The Lo-Fi flag is "always-on" and Lo-Fi is being used. Lo-Fi header | 267 // The Lo-Fi flag is "always-on" and Lo-Fi is being used. Lo-Fi header |
284 // should be added. | 268 // should be added. |
285 AllocateRequestInfoForTesting( | 269 AllocateRequestInfoForTesting( |
286 request.get(), content::RESOURCE_TYPE_SUB_FRAME, previews_state); | 270 request.get(), content::RESOURCE_TYPE_SUB_FRAME, previews_state); |
287 headers.Clear(); | 271 headers.Clear(); |
288 NotifyBeforeSendHeaders(&headers, request.get(), true); | 272 NotifyBeforeSendHeaders(&headers, request.get(), true); |
289 VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi, | 273 VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi, |
290 headers); | 274 headers); |
291 VerifyLitePageHeader(false, false, headers); | 275 VerifyLitePageHeader(false, false, headers); |
292 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
293 | 276 |
294 // The Lo-Fi flag is "cellular-only" and Lo-Fi is being used. Lo-Fi header | 277 // The Lo-Fi flag is "cellular-only" and Lo-Fi is being used. Lo-Fi header |
295 // should be added. | 278 // should be added. |
296 command_line->AppendSwitchASCII( | 279 command_line->AppendSwitchASCII( |
297 switches::kDataReductionProxyLoFi, | 280 switches::kDataReductionProxyLoFi, |
298 switches::kDataReductionProxyLoFiValueCellularOnly); | 281 switches::kDataReductionProxyLoFiValueCellularOnly); |
299 headers.Clear(); | 282 headers.Clear(); |
300 NotifyBeforeSendHeaders(&headers, request.get(), true); | 283 NotifyBeforeSendHeaders(&headers, request.get(), true); |
301 VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi, | 284 VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi, |
302 headers); | 285 headers); |
303 VerifyLitePageHeader(false, false, headers); | 286 VerifyLitePageHeader(false, false, headers); |
304 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
305 data = DataReductionProxyData::GetData(*request); | 287 data = DataReductionProxyData::GetData(*request); |
306 // |lofi_requested| should be set to false when Lo-Fi is enabled using | 288 // |lofi_requested| should be set to false when Lo-Fi is enabled using |
307 // flags. | 289 // flags. |
308 EXPECT_FALSE(data->lofi_requested()); | 290 EXPECT_FALSE(data->lofi_requested()); |
309 | 291 |
310 // The Lo-Fi flag is "slow-connections-only" and Lo-Fi is being used. Lo-Fi | 292 // The Lo-Fi flag is "slow-connections-only" and Lo-Fi is being used. Lo-Fi |
311 // header should be added. | 293 // header should be added. |
312 command_line->AppendSwitchASCII( | 294 command_line->AppendSwitchASCII( |
313 switches::kDataReductionProxyLoFi, | 295 switches::kDataReductionProxyLoFi, |
314 switches::kDataReductionProxyLoFiValueSlowConnectionsOnly); | 296 switches::kDataReductionProxyLoFiValueSlowConnectionsOnly); |
315 headers.Clear(); | 297 headers.Clear(); |
316 NotifyBeforeSendHeaders(&headers, request.get(), true); | 298 NotifyBeforeSendHeaders(&headers, request.get(), true); |
317 VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi, | 299 VerifyLoFiHeader(!tests[i].is_using_lite_page, !tests[i].is_using_lofi, |
318 headers); | 300 headers); |
319 VerifyLitePageHeader(false, false, headers); | 301 VerifyLitePageHeader(false, false, headers); |
320 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
321 data = DataReductionProxyData::GetData(*request); | 302 data = DataReductionProxyData::GetData(*request); |
322 // |lofi_requested| should be set to false when Lo-Fi is enabled using | 303 // |lofi_requested| should be set to false when Lo-Fi is enabled using |
323 // flags. | 304 // flags. |
324 EXPECT_FALSE(data->lofi_requested()); | 305 EXPECT_FALSE(data->lofi_requested()); |
325 } | 306 } |
326 } | 307 } |
327 | 308 |
328 TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) { | 309 TEST_F(ContentLoFiDeciderTest, LoFiEnabledFieldTrial) { |
329 base::FieldTrialList field_trial_list(nullptr); | 310 base::FieldTrialList field_trial_list(nullptr); |
330 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), | 311 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
386 bool is_lofi_resource_type = | 367 bool is_lofi_resource_type = |
387 !(tests[i].resource_type == content::RESOURCE_TYPE_MAIN_FRAME || | 368 !(tests[i].resource_type == content::RESOURCE_TYPE_MAIN_FRAME || |
388 tests[i].resource_type == content::RESOURCE_TYPE_STYLESHEET || | 369 tests[i].resource_type == content::RESOURCE_TYPE_STYLESHEET || |
389 tests[i].resource_type == content::RESOURCE_TYPE_SCRIPT || | 370 tests[i].resource_type == content::RESOURCE_TYPE_SCRIPT || |
390 tests[i].resource_type == content::RESOURCE_TYPE_FONT_RESOURCE || | 371 tests[i].resource_type == content::RESOURCE_TYPE_FONT_RESOURCE || |
391 tests[i].resource_type == content::RESOURCE_TYPE_MEDIA || | 372 tests[i].resource_type == content::RESOURCE_TYPE_MEDIA || |
392 tests[i].resource_type == content::RESOURCE_TYPE_CSP_REPORT); | 373 tests[i].resource_type == content::RESOURCE_TYPE_CSP_REPORT); |
393 | 374 |
394 VerifyLoFiHeader(is_lofi_resource_type, !tests[i].is_using_lofi, headers); | 375 VerifyLoFiHeader(is_lofi_resource_type, !tests[i].is_using_lofi, headers); |
395 VerifyLitePageHeader(false, false, headers); | 376 VerifyLitePageHeader(false, false, headers); |
396 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
397 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); | 377 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); |
398 EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i; | 378 EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i; |
399 } | 379 } |
400 } | 380 } |
401 | 381 |
402 TEST_F(ContentLoFiDeciderTest, LoFiControlFieldTrial) { | 382 TEST_F(ContentLoFiDeciderTest, LoFiControlFieldTrial) { |
403 base::FieldTrialList field_trial_list(nullptr); | 383 base::FieldTrialList field_trial_list(nullptr); |
404 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), | 384 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), |
405 "Control"); | 385 "Control"); |
406 // Enable Lo-Fi. | 386 // Enable Lo-Fi. |
407 const struct { | 387 const struct { |
408 bool is_using_lofi; | 388 bool is_using_lofi; |
409 bool is_main_frame; | 389 bool is_main_frame; |
410 } tests[] = {{false, false}, {false, true}, {true, false}, {true, true}}; | 390 } tests[] = {{false, false}, {false, true}, {true, false}, {true, true}}; |
411 | 391 |
412 for (size_t i = 0; i < arraysize(tests); ++i) { | 392 for (size_t i = 0; i < arraysize(tests); ++i) { |
413 std::unique_ptr<net::URLRequest> request = CreateRequest( | 393 std::unique_ptr<net::URLRequest> request = CreateRequest( |
414 tests[i].is_main_frame, tests[i].is_using_lofi ? content::SERVER_LOFI_ON | 394 tests[i].is_main_frame, tests[i].is_using_lofi ? content::SERVER_LOFI_ON |
415 : content::PREVIEWS_OFF); | 395 : content::PREVIEWS_OFF); |
416 net::HttpRequestHeaders headers; | 396 net::HttpRequestHeaders headers; |
417 NotifyBeforeSendHeaders(&headers, request.get(), true); | 397 NotifyBeforeSendHeaders(&headers, request.get(), true); |
418 VerifyLoFiHeader(false, false, headers); | 398 VerifyLoFiHeader(false, false, headers); |
419 VerifyLitePageHeader(false, false, headers); | 399 VerifyLitePageHeader(false, false, headers); |
420 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
421 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); | 400 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); |
422 EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i; | 401 EXPECT_EQ(tests[i].is_using_lofi, data->lofi_requested()) << i; |
423 } | 402 } |
424 } | 403 } |
425 | 404 |
426 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrial) { | 405 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrial) { |
427 base::FieldTrialList field_trial_list(nullptr); | 406 base::FieldTrialList field_trial_list(nullptr); |
428 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), | 407 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), |
429 "Enabled_Preview"); | 408 "Enabled_Preview"); |
430 // Enable Lo-Fi. | 409 // Enable Lo-Fi. |
431 const struct { | 410 const struct { |
432 bool is_using_lite_page; | 411 bool is_using_lite_page; |
433 bool is_main_frame; | 412 bool is_main_frame; |
434 } tests[] = { | 413 } tests[] = { |
435 {false, false}, {true, false}, {false, true}, {true, true}, | 414 {false, false}, {true, false}, {false, true}, {true, true}, |
436 }; | 415 }; |
437 | 416 |
438 for (size_t i = 0; i < arraysize(tests); ++i) { | 417 for (size_t i = 0; i < arraysize(tests); ++i) { |
439 std::unique_ptr<net::URLRequest> request = | 418 std::unique_ptr<net::URLRequest> request = |
440 CreateRequest(tests[i].is_main_frame, tests[i].is_using_lite_page | 419 CreateRequest(tests[i].is_main_frame, tests[i].is_using_lite_page |
441 ? content::SERVER_LITE_PAGE_ON | 420 ? content::SERVER_LITE_PAGE_ON |
442 : content::PREVIEWS_OFF); | 421 : content::PREVIEWS_OFF); |
443 net::HttpRequestHeaders headers; | 422 net::HttpRequestHeaders headers; |
444 NotifyBeforeSendHeaders(&headers, request.get(), true); | 423 NotifyBeforeSendHeaders(&headers, request.get(), true); |
445 VerifyLoFiHeader(false, false, headers); | 424 VerifyLoFiHeader(false, false, headers); |
446 VerifyLitePageHeader(tests[i].is_main_frame, !tests[i].is_using_lite_page, | 425 VerifyLitePageHeader(tests[i].is_main_frame, !tests[i].is_using_lite_page, |
447 headers); | 426 headers); |
448 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
449 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); | 427 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); |
450 EXPECT_EQ(tests[i].is_using_lite_page, data->lofi_requested()) << i; | 428 EXPECT_EQ(tests[i].is_using_lite_page, data->lofi_requested()) << i; |
451 } | 429 } |
452 } | 430 } |
453 | 431 |
454 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackEnabled) { | 432 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackEnabled) { |
455 base::FieldTrialList field_trial_list(nullptr); | 433 base::FieldTrialList field_trial_list(nullptr); |
456 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), | 434 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), |
457 "Enabled_Preview"); | 435 "Enabled_Preview"); |
458 base::FieldTrialList::CreateFieldTrial( | 436 base::FieldTrialList::CreateFieldTrial( |
(...skipping 23 matching lines...) Expand all Loading... |
482 CreateRequest(tests[i].is_main_frame, previews_state); | 460 CreateRequest(tests[i].is_main_frame, previews_state); |
483 net::HttpRequestHeaders headers; | 461 net::HttpRequestHeaders headers; |
484 NotifyBeforeSendHeaders(&headers, request.get(), true); | 462 NotifyBeforeSendHeaders(&headers, request.get(), true); |
485 VerifyLoFiHeader(!tests[i].is_main_frame && !tests[i].is_using_lite_page, | 463 VerifyLoFiHeader(!tests[i].is_main_frame && !tests[i].is_using_lite_page, |
486 !tests[i].is_main_frame && !tests[i].is_using_lofi && | 464 !tests[i].is_main_frame && !tests[i].is_using_lofi && |
487 !tests[i].is_using_lite_page, | 465 !tests[i].is_using_lite_page, |
488 headers); | 466 headers); |
489 VerifyLitePageHeader(tests[i].is_main_frame, | 467 VerifyLitePageHeader(tests[i].is_main_frame, |
490 tests[i].is_main_frame && !tests[i].is_using_lite_page, | 468 tests[i].is_main_frame && !tests[i].is_using_lite_page, |
491 headers); | 469 headers); |
492 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
493 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); | 470 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); |
494 EXPECT_EQ(tests[i].is_using_lofi || tests[i].is_using_lite_page, | 471 EXPECT_EQ(tests[i].is_using_lofi || tests[i].is_using_lite_page, |
495 data->lofi_requested()) | 472 data->lofi_requested()) |
496 << i; | 473 << i; |
497 } | 474 } |
498 } | 475 } |
499 | 476 |
500 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackDisabled) { | 477 TEST_F(ContentLoFiDeciderTest, LitePageFieldTrialFallbackDisabled) { |
501 base::FieldTrialList field_trial_list(nullptr); | 478 base::FieldTrialList field_trial_list(nullptr); |
502 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), | 479 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), |
(...skipping 19 matching lines...) Expand all Loading... |
522 previews_state = content::PREVIEWS_OFF; | 499 previews_state = content::PREVIEWS_OFF; |
523 | 500 |
524 std::unique_ptr<net::URLRequest> request = | 501 std::unique_ptr<net::URLRequest> request = |
525 CreateRequest(tests[i].is_main_frame, previews_state); | 502 CreateRequest(tests[i].is_main_frame, previews_state); |
526 net::HttpRequestHeaders headers; | 503 net::HttpRequestHeaders headers; |
527 NotifyBeforeSendHeaders(&headers, request.get(), true); | 504 NotifyBeforeSendHeaders(&headers, request.get(), true); |
528 VerifyLoFiHeader(false, false, headers); | 505 VerifyLoFiHeader(false, false, headers); |
529 VerifyLitePageHeader(tests[i].is_main_frame, | 506 VerifyLitePageHeader(tests[i].is_main_frame, |
530 tests[i].is_main_frame && !tests[i].is_using_lite_page, | 507 tests[i].is_main_frame && !tests[i].is_using_lite_page, |
531 headers); | 508 headers); |
532 VerifyLitePageIgnoreBlacklistHeader(false, headers); | |
533 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); | 509 DataReductionProxyData* data = DataReductionProxyData::GetData(*request); |
534 EXPECT_EQ(tests[i].is_using_lofi || tests[i].is_using_lite_page, | 510 EXPECT_EQ(tests[i].is_using_lofi || tests[i].is_using_lite_page, |
535 data->lofi_requested()) | 511 data->lofi_requested()) |
536 << i; | 512 << i; |
537 } | 513 } |
538 } | 514 } |
539 | 515 |
540 TEST_F(ContentLoFiDeciderTest, AutoLoFi) { | 516 TEST_F(ContentLoFiDeciderTest, AutoLoFi) { |
541 const struct { | 517 const struct { |
542 bool auto_lofi_enabled_group; | 518 bool auto_lofi_enabled_group; |
(...skipping 199 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
742 TEST_F(ContentLoFiDeciderTest, RemoveAcceptTransformHeader) { | 718 TEST_F(ContentLoFiDeciderTest, RemoveAcceptTransformHeader) { |
743 std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider( | 719 std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider( |
744 new data_reduction_proxy::ContentLoFiDecider()); | 720 new data_reduction_proxy::ContentLoFiDecider()); |
745 net::HttpRequestHeaders headers; | 721 net::HttpRequestHeaders headers; |
746 headers.SetHeader(chrome_proxy_accept_transform_header(), "Foo"); | 722 headers.SetHeader(chrome_proxy_accept_transform_header(), "Foo"); |
747 EXPECT_TRUE(headers.HasHeader(chrome_proxy_accept_transform_header())); | 723 EXPECT_TRUE(headers.HasHeader(chrome_proxy_accept_transform_header())); |
748 lofi_decider->RemoveAcceptTransformHeader(&headers); | 724 lofi_decider->RemoveAcceptTransformHeader(&headers); |
749 EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header())); | 725 EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header())); |
750 } | 726 } |
751 | 727 |
752 TEST_F(ContentLoFiDeciderTest, MaybeIgnoreBlacklist) { | |
753 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess(); | |
754 command_line->InitFromArgv(command_line->argv()); | |
755 std::unique_ptr<data_reduction_proxy::ContentLoFiDecider> lofi_decider( | |
756 new data_reduction_proxy::ContentLoFiDecider()); | |
757 net::HttpRequestHeaders headers; | |
758 lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers); | |
759 EXPECT_FALSE(headers.HasHeader(chrome_proxy_header())); | |
760 | |
761 headers.SetHeader(chrome_proxy_header(), "Foo"); | |
762 lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers); | |
763 std::string header_value; | |
764 headers.GetHeader(chrome_proxy_header(), &header_value); | |
765 EXPECT_EQ("Foo", header_value); | |
766 | |
767 headers.RemoveHeader(chrome_proxy_header()); | |
768 command_line->AppendSwitch(switches::kEnableDataReductionProxyLitePage); | |
769 headers.SetHeader(chrome_proxy_accept_transform_header(), "empty-image"); | |
770 lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers); | |
771 EXPECT_FALSE(headers.HasHeader(chrome_proxy_header())); | |
772 | |
773 headers.SetHeader(chrome_proxy_accept_transform_header(), "lite-page"); | |
774 lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers); | |
775 EXPECT_TRUE(headers.HasHeader(chrome_proxy_header())); | |
776 headers.GetHeader(chrome_proxy_header(), &header_value); | |
777 EXPECT_EQ("exp=ignore_preview_blacklist", header_value); | |
778 | |
779 headers.SetHeader(chrome_proxy_header(), "Foo"); | |
780 lofi_decider->MaybeSetIgnorePreviewsBlacklistDirective(&headers); | |
781 EXPECT_TRUE(headers.HasHeader(chrome_proxy_header())); | |
782 headers.GetHeader(chrome_proxy_header(), &header_value); | |
783 EXPECT_EQ("Foo, exp=ignore_preview_blacklist", header_value); | |
784 } | |
785 | |
786 TEST_F(ContentLoFiDeciderTest, NoTransformDoesNotAddHeader) { | 728 TEST_F(ContentLoFiDeciderTest, NoTransformDoesNotAddHeader) { |
787 base::FieldTrialList field_trial_list(nullptr); | 729 base::FieldTrialList field_trial_list(nullptr); |
788 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), | 730 base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(), |
789 "Enabled"); | 731 "Enabled"); |
790 std::unique_ptr<net::URLRequest> request = | 732 std::unique_ptr<net::URLRequest> request = |
791 CreateRequest(false, content::PREVIEWS_NO_TRANSFORM); | 733 CreateRequest(false, content::PREVIEWS_NO_TRANSFORM); |
792 net::HttpRequestHeaders headers; | 734 net::HttpRequestHeaders headers; |
793 NotifyBeforeSendHeaders(&headers, request.get(), true); | 735 NotifyBeforeSendHeaders(&headers, request.get(), true); |
794 EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header())); | 736 EXPECT_FALSE(headers.HasHeader(chrome_proxy_accept_transform_header())); |
795 } | 737 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
840 content::CLIENT_LOFI_AUTO_RELOAD))); | 782 content::CLIENT_LOFI_AUTO_RELOAD))); |
841 | 783 |
842 // IsClientLoFiAutoReloadRequest() should return false for any request without | 784 // IsClientLoFiAutoReloadRequest() should return false for any request without |
843 // the CLIENT_LOFI_AUTO_RELOAD bit set. | 785 // the CLIENT_LOFI_AUTO_RELOAD bit set. |
844 EXPECT_FALSE(ContentLoFiDecider().IsClientLoFiAutoReloadRequest( | 786 EXPECT_FALSE(ContentLoFiDecider().IsClientLoFiAutoReloadRequest( |
845 *CreateRequestByType(content::RESOURCE_TYPE_IMAGE, false, | 787 *CreateRequestByType(content::RESOURCE_TYPE_IMAGE, false, |
846 content::PREVIEWS_NO_TRANSFORM))); | 788 content::PREVIEWS_NO_TRANSFORM))); |
847 } | 789 } |
848 | 790 |
849 } // namespace data_reduction_proxy | 791 } // namespace data_reduction_proxy |
OLD | NEW |