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

Side by Side Diff: chrome/browser/extensions/api/web_request/web_request_api_unittest.cc

Issue 1871713002: Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase and fix header 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 <stddef.h> 5 #include <stddef.h>
6 #include <stdint.h> 6 #include <stdint.h>
7 7
8 #include <map> 8 #include <map>
9 #include <memory>
9 #include <queue> 10 #include <queue>
10 #include <tuple> 11 #include <tuple>
11 12
12 #include "base/bind.h" 13 #include "base/bind.h"
13 #include "base/callback.h" 14 #include "base/callback.h"
14 #include "base/files/file_path.h" 15 #include "base/files/file_path.h"
15 #include "base/json/json_reader.h" 16 #include "base/json/json_reader.h"
16 #include "base/json/json_string_value_serializer.h" 17 #include "base/json/json_string_value_serializer.h"
17 #include "base/location.h" 18 #include "base/location.h"
18 #include "base/macros.h" 19 #include "base/macros.h"
19 #include "base/memory/scoped_ptr.h" 20 #include "base/memory/ptr_util.h"
20 #include "base/memory/weak_ptr.h" 21 #include "base/memory/weak_ptr.h"
21 #include "base/single_thread_task_runner.h" 22 #include "base/single_thread_task_runner.h"
22 #include "base/stl_util.h" 23 #include "base/stl_util.h"
23 #include "base/strings/string_piece.h" 24 #include "base/strings/string_piece.h"
24 #include "base/strings/string_split.h" 25 #include "base/strings/string_split.h"
25 #include "base/strings/stringprintf.h" 26 #include "base/strings/stringprintf.h"
26 #include "base/strings/utf_string_conversions.h" 27 #include "base/strings/utf_string_conversions.h"
27 #include "base/thread_task_runner_handle.h" 28 #include "base/thread_task_runner_handle.h"
28 #include "base/time/time.h" 29 #include "base/time/time.h"
29 #include "chrome/browser/content_settings/cookie_settings_factory.h" 30 #include "chrome/browser/content_settings/cookie_settings_factory.h"
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after
211 const std::vector<char>& bytes_2); 212 const std::vector<char>& bytes_2);
212 213
213 content::TestBrowserThreadBundle thread_bundle_; 214 content::TestBrowserThreadBundle thread_bundle_;
214 TestingProfile profile_; 215 TestingProfile profile_;
215 TestingProfileManager profile_manager_; 216 TestingProfileManager profile_manager_;
216 net::TestDelegate delegate_; 217 net::TestDelegate delegate_;
217 BooleanPrefMember enable_referrers_; 218 BooleanPrefMember enable_referrers_;
218 TestIPCSender ipc_sender_; 219 TestIPCSender ipc_sender_;
219 scoped_refptr<EventRouterForwarder> event_router_; 220 scoped_refptr<EventRouterForwarder> event_router_;
220 scoped_refptr<InfoMap> extension_info_map_; 221 scoped_refptr<InfoMap> extension_info_map_;
221 scoped_ptr<ChromeNetworkDelegate> network_delegate_; 222 std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
222 scoped_ptr<net::TestURLRequestContext> context_; 223 std::unique_ptr<net::TestURLRequestContext> context_;
223 }; 224 };
224 225
225 // Tests that we handle disagreements among extensions about responses to 226 // Tests that we handle disagreements among extensions about responses to
226 // blocking events (redirection) by choosing the response from the 227 // blocking events (redirection) by choosing the response from the
227 // most-recently-installed extension. 228 // most-recently-installed extension.
228 TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) { 229 TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) {
229 std::string extension1_id("1"); 230 std::string extension1_id("1");
230 std::string extension2_id("2"); 231 std::string extension2_id("2");
231 ExtensionWebRequestEventRouter::RequestFilter filter; 232 ExtensionWebRequestEventRouter::RequestFilter filter;
232 const std::string kEventName(web_request::OnBeforeRequest::kEventName); 233 const std::string kEventName(web_request::OnBeforeRequest::kEventName);
233 base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_); 234 base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
234 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 235 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
235 &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName, 236 &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
236 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0, 237 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
237 ipc_sender_factory.GetWeakPtr()); 238 ipc_sender_factory.GetWeakPtr());
238 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 239 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
239 &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName, 240 &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
240 kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0, 241 kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
241 ipc_sender_factory.GetWeakPtr()); 242 ipc_sender_factory.GetWeakPtr());
242 243
243 net::URLRequestJobFactoryImpl job_factory; 244 net::URLRequestJobFactoryImpl job_factory;
244 job_factory.SetProtocolHandler( 245 job_factory.SetProtocolHandler(
245 url::kAboutScheme, 246 url::kAboutScheme,
246 make_scoped_ptr(new about_handler::AboutProtocolHandler())); 247 base::WrapUnique(new about_handler::AboutProtocolHandler()));
247 context_->set_job_factory(&job_factory); 248 context_->set_job_factory(&job_factory);
248 249
249 GURL redirect_url("about:redirected"); 250 GURL redirect_url("about:redirected");
250 GURL not_chosen_redirect_url("about:not_chosen"); 251 GURL not_chosen_redirect_url("about:not_chosen");
251 252
252 scoped_ptr<net::URLRequest> request(context_->CreateRequest( 253 std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
253 GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_)); 254 GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
254 { 255 {
255 // onBeforeRequest will be dispatched twice initially. The second response - 256 // onBeforeRequest will be dispatched twice initially. The second response -
256 // the redirect - should win, since it has a later |install_time|. The 257 // the redirect - should win, since it has a later |install_time|. The
257 // redirect will dispatch another pair of onBeforeRequest. There, the first 258 // redirect will dispatch another pair of onBeforeRequest. There, the first
258 // response should win (later |install_time|). 259 // response should win (later |install_time|).
259 ExtensionWebRequestEventRouter::EventResponse* response = NULL; 260 ExtensionWebRequestEventRouter::EventResponse* response = NULL;
260 261
261 // Extension1 response. Arrives first, but ignored due to install_time. 262 // Extension1 response. Arrives first, but ignored due to install_time.
262 response = new ExtensionWebRequestEventRouter::EventResponse( 263 response = new ExtensionWebRequestEventRouter::EventResponse(
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
297 298
298 EXPECT_TRUE(!request->is_pending()); 299 EXPECT_TRUE(!request->is_pending());
299 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status()); 300 EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
300 EXPECT_EQ(0, request->status().error()); 301 EXPECT_EQ(0, request->status().error());
301 EXPECT_EQ(redirect_url, request->url()); 302 EXPECT_EQ(redirect_url, request->url());
302 EXPECT_EQ(2U, request->url_chain().size()); 303 EXPECT_EQ(2U, request->url_chain().size());
303 EXPECT_EQ(0U, ipc_sender_.GetNumTasks()); 304 EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
304 } 305 }
305 306
306 // Now test the same thing but the extensions answer in reverse order. 307 // Now test the same thing but the extensions answer in reverse order.
307 scoped_ptr<net::URLRequest> request2(context_->CreateRequest( 308 std::unique_ptr<net::URLRequest> request2(context_->CreateRequest(
308 GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_)); 309 GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_));
309 { 310 {
310 ExtensionWebRequestEventRouter::EventResponse* response = NULL; 311 ExtensionWebRequestEventRouter::EventResponse* response = NULL;
311 312
312 // Extension2 response. Arrives first, and chosen because of install_time. 313 // Extension2 response. Arrives first, and chosen because of install_time.
313 response = new ExtensionWebRequestEventRouter::EventResponse( 314 response = new ExtensionWebRequestEventRouter::EventResponse(
314 extension2_id, base::Time::FromDoubleT(2)); 315 extension2_id, base::Time::FromDoubleT(2));
315 response->new_url = redirect_url; 316 response->new_url = redirect_url;
316 ipc_sender_.PushTask( 317 ipc_sender_.PushTask(
317 base::Bind(&EventHandledOnIOThread, 318 base::Bind(&EventHandledOnIOThread,
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
371 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 372 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
372 &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName, 373 &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
373 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0, 374 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
374 ipc_sender_factory.GetWeakPtr()); 375 ipc_sender_factory.GetWeakPtr());
375 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 376 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
376 &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName, 377 &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
377 kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0, 378 kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
378 ipc_sender_factory.GetWeakPtr()); 379 ipc_sender_factory.GetWeakPtr());
379 380
380 GURL request_url("about:blank"); 381 GURL request_url("about:blank");
381 scoped_ptr<net::URLRequest> request(context_->CreateRequest( 382 std::unique_ptr<net::URLRequest> request(
382 request_url, net::DEFAULT_PRIORITY, &delegate_)); 383 context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
383 384
384 // onBeforeRequest will be dispatched twice. The second response - 385 // onBeforeRequest will be dispatched twice. The second response -
385 // the redirect - would win, since it has a later |install_time|, but 386 // the redirect - would win, since it has a later |install_time|, but
386 // the first response takes precedence because cancel >> redirect. 387 // the first response takes precedence because cancel >> redirect.
387 GURL redirect_url("about:redirected"); 388 GURL redirect_url("about:redirected");
388 ExtensionWebRequestEventRouter::EventResponse* response = NULL; 389 ExtensionWebRequestEventRouter::EventResponse* response = NULL;
389 390
390 // Extension1 response. Arrives first, would be ignored in principle due to 391 // Extension1 response. Arrives first, would be ignored in principle due to
391 // install_time but "cancel" always wins. 392 // install_time but "cancel" always wins.
392 response = new ExtensionWebRequestEventRouter::EventResponse( 393 response = new ExtensionWebRequestEventRouter::EventResponse(
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
439 base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_); 440 base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
440 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 441 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
441 &profile_, extension_id, extension_id, events::FOR_TEST, kEventName, 442 &profile_, extension_id, extension_id, events::FOR_TEST, kEventName,
442 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0, 443 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
443 ipc_sender_factory.GetWeakPtr()); 444 ipc_sender_factory.GetWeakPtr());
444 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 445 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
445 &profile_, extension_id, extension_id, events::FOR_TEST, kEventName2, 446 &profile_, extension_id, extension_id, events::FOR_TEST, kEventName2,
446 kEventName2 + "/1", filter, 0, 0, 0, ipc_sender_factory.GetWeakPtr()); 447 kEventName2 + "/1", filter, 0, 0, 0, ipc_sender_factory.GetWeakPtr());
447 448
448 GURL request_url("about:blank"); 449 GURL request_url("about:blank");
449 scoped_ptr<net::URLRequest> request(context_->CreateRequest( 450 std::unique_ptr<net::URLRequest> request(
450 request_url, net::DEFAULT_PRIORITY, &delegate_)); 451 context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
451 452
452 ExtensionWebRequestEventRouter::EventResponse* response = NULL; 453 ExtensionWebRequestEventRouter::EventResponse* response = NULL;
453 454
454 // Extension response for the OnBeforeRequest handler. This should not be 455 // Extension response for the OnBeforeRequest handler. This should not be
455 // processed because request is canceled before the handler responds. 456 // processed because request is canceled before the handler responds.
456 response = new ExtensionWebRequestEventRouter::EventResponse( 457 response = new ExtensionWebRequestEventRouter::EventResponse(
457 extension_id, base::Time::FromDoubleT(1)); 458 extension_id, base::Time::FromDoubleT(1));
458 GURL redirect_url("about:redirected"); 459 GURL redirect_url("about:redirected");
459 response->new_url = redirect_url; 460 response->new_url = redirect_url;
460 ipc_sender_.PushTask( 461 ipc_sender_.PushTask(
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
502 503
503 } // namespace 504 } // namespace
504 505
505 void ExtensionWebRequestTest::FireURLRequestWithData( 506 void ExtensionWebRequestTest::FireURLRequestWithData(
506 const std::string& method, 507 const std::string& method,
507 const char* content_type, 508 const char* content_type,
508 const std::vector<char>& bytes_1, 509 const std::vector<char>& bytes_1,
509 const std::vector<char>& bytes_2) { 510 const std::vector<char>& bytes_2) {
510 // The request URL can be arbitrary but must have an HTTP or HTTPS scheme. 511 // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
511 GURL request_url("http://www.example.com"); 512 GURL request_url("http://www.example.com");
512 scoped_ptr<net::URLRequest> request(context_->CreateRequest( 513 std::unique_ptr<net::URLRequest> request(
513 request_url, net::DEFAULT_PRIORITY, &delegate_)); 514 context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
514 request->set_method(method); 515 request->set_method(method);
515 if (content_type != NULL) { 516 if (content_type != NULL) {
516 request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType, 517 request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
517 content_type, 518 content_type,
518 true /* overwrite */); 519 true /* overwrite */);
519 } 520 }
520 std::vector<scoped_ptr<net::UploadElementReader>> element_readers; 521 std::vector<std::unique_ptr<net::UploadElementReader>> element_readers;
521 element_readers.push_back(make_scoped_ptr( 522 element_readers.push_back(base::WrapUnique(
522 new net::UploadBytesElementReader(&(bytes_1[0]), bytes_1.size()))); 523 new net::UploadBytesElementReader(&(bytes_1[0]), bytes_1.size())));
523 element_readers.push_back(make_scoped_ptr(new net::UploadFileElementReader( 524 element_readers.push_back(base::WrapUnique(new net::UploadFileElementReader(
524 base::ThreadTaskRunnerHandle::Get().get(), base::FilePath(), 0, 0, 525 base::ThreadTaskRunnerHandle::Get().get(), base::FilePath(), 0, 0,
525 base::Time()))); 526 base::Time())));
526 element_readers.push_back(make_scoped_ptr( 527 element_readers.push_back(base::WrapUnique(
527 new net::UploadBytesElementReader(&(bytes_2[0]), bytes_2.size()))); 528 new net::UploadBytesElementReader(&(bytes_2[0]), bytes_2.size())));
528 request->set_upload(make_scoped_ptr( 529 request->set_upload(base::WrapUnique(
529 new net::ElementsUploadDataStream(std::move(element_readers), 0))); 530 new net::ElementsUploadDataStream(std::move(element_readers), 0)));
530 ipc_sender_.PushTask(base::Bind(&base::DoNothing)); 531 ipc_sender_.PushTask(base::Bind(&base::DoNothing));
531 request->Start(); 532 request->Start();
532 } 533 }
533 534
534 TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) { 535 TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) {
535 // We verify that URLRequest body is accessible to OnBeforeRequest listeners. 536 // We verify that URLRequest body is accessible to OnBeforeRequest listeners.
536 // These testing steps are repeated twice in a row: 537 // These testing steps are repeated twice in a row:
537 // 1. Register an extension requesting "requestBody" in ExtraInfoSpec and 538 // 1. Register an extension requesting "requestBody" in ExtraInfoSpec and
538 // file a POST URLRequest with a multipart-encoded form. See it getting 539 // file a POST URLRequest with a multipart-encoded form. See it getting
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
579 const std::string kErrorPath(kBodyPath + "." + keys::kRequestBodyErrorKey); 580 const std::string kErrorPath(kBodyPath + "." + keys::kRequestBodyErrorKey);
580 const std::string* const kPath[] = { 581 const std::string* const kPath[] = {
581 &kFormDataPath, 582 &kFormDataPath,
582 &kBodyPath, 583 &kBodyPath,
583 &kRawPath, 584 &kRawPath,
584 &kRawPath 585 &kRawPath
585 }; 586 };
586 // Contents of formData. 587 // Contents of formData.
587 const char kFormData[] = 588 const char kFormData[] =
588 "{\"A\":[\"test text\"],\"B\":[\"\"],\"C\":[\"test password\"]}"; 589 "{\"A\":[\"test text\"],\"B\":[\"\"],\"C\":[\"test password\"]}";
589 scoped_ptr<const base::Value> form_data = base::JSONReader::Read(kFormData); 590 std::unique_ptr<const base::Value> form_data =
591 base::JSONReader::Read(kFormData);
590 ASSERT_TRUE(form_data.get() != NULL); 592 ASSERT_TRUE(form_data.get() != NULL);
591 ASSERT_TRUE(form_data->GetType() == base::Value::TYPE_DICTIONARY); 593 ASSERT_TRUE(form_data->GetType() == base::Value::TYPE_DICTIONARY);
592 // Contents of raw. 594 // Contents of raw.
593 base::ListValue raw; 595 base::ListValue raw;
594 extensions::subtle::AppendKeyValuePair( 596 extensions::subtle::AppendKeyValuePair(
595 keys::kRequestBodyRawBytesKey, 597 keys::kRequestBodyRawBytesKey,
596 BinaryValue::CreateWithCopiedBuffer(kPlainBlock1, kPlainBlock1Length), 598 BinaryValue::CreateWithCopiedBuffer(kPlainBlock1, kPlainBlock1Length),
597 &raw); 599 &raw);
598 extensions::subtle::AppendKeyValuePair( 600 extensions::subtle::AppendKeyValuePair(
599 keys::kRequestBodyRawFileKey, 601 keys::kRequestBodyRawFileKey,
(...skipping 196 matching lines...) Expand 10 before | Expand all | Expand 10 after
796 // Subscribe to OnBeforeRequest with requestBody requirement. 798 // Subscribe to OnBeforeRequest with requestBody requirement.
797 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 799 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
798 &profile_, extension_id, extension_id, events::FOR_TEST, kEventName, 800 &profile_, extension_id, extension_id, events::FOR_TEST, kEventName,
799 kEventName + "/1", filter, extra_info_spec, 0, 0, 801 kEventName + "/1", filter, extra_info_spec, 0, 0,
800 ipc_sender_factory.GetWeakPtr()); 802 ipc_sender_factory.GetWeakPtr());
801 803
802 // The request URL can be arbitrary but must have an HTTP or HTTPS scheme. 804 // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
803 const GURL request_url("http://www.example.com"); 805 const GURL request_url("http://www.example.com");
804 806
805 for (size_t i = 0; i < arraysize(kMethods); ++i) { 807 for (size_t i = 0; i < arraysize(kMethods); ++i) {
806 scoped_ptr<net::URLRequest> request(context_->CreateRequest( 808 std::unique_ptr<net::URLRequest> request(context_->CreateRequest(
807 request_url, net::DEFAULT_PRIORITY, &delegate_)); 809 request_url, net::DEFAULT_PRIORITY, &delegate_));
808 request->set_method(kMethods[i]); 810 request->set_method(kMethods[i]);
809 ipc_sender_.PushTask(base::Bind(&base::DoNothing)); 811 ipc_sender_.PushTask(base::Bind(&base::DoNothing));
810 request->Start(); 812 request->Start();
811 } 813 }
812 814
813 // We inspect the result in the message list of |ipc_sender_| later. 815 // We inspect the result in the message list of |ipc_sender_| later.
814 base::MessageLoop::current()->RunUntilIdle(); 816 base::MessageLoop::current()->RunUntilIdle();
815 817
816 ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener( 818 ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
886 } 888 }
887 889
888 content::TestBrowserThreadBundle thread_bundle_; 890 content::TestBrowserThreadBundle thread_bundle_;
889 TestingProfile profile_; 891 TestingProfile profile_;
890 TestingProfileManager profile_manager_; 892 TestingProfileManager profile_manager_;
891 net::TestDelegate delegate_; 893 net::TestDelegate delegate_;
892 BooleanPrefMember enable_referrers_; 894 BooleanPrefMember enable_referrers_;
893 TestIPCSender ipc_sender_; 895 TestIPCSender ipc_sender_;
894 scoped_refptr<EventRouterForwarder> event_router_; 896 scoped_refptr<EventRouterForwarder> event_router_;
895 scoped_refptr<InfoMap> extension_info_map_; 897 scoped_refptr<InfoMap> extension_info_map_;
896 scoped_ptr<ChromeNetworkDelegate> network_delegate_; 898 std::unique_ptr<ChromeNetworkDelegate> network_delegate_;
897 scoped_ptr<net::MockHostResolver> host_resolver_; 899 std::unique_ptr<net::MockHostResolver> host_resolver_;
898 scoped_ptr<net::TestURLRequestContext> context_; 900 std::unique_ptr<net::TestURLRequestContext> context_;
899 }; 901 };
900 902
901 TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) { 903 TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) {
902 std::string extension1_id("1"); 904 std::string extension1_id("1");
903 std::string extension2_id("2"); 905 std::string extension2_id("2");
904 std::string extension3_id("3"); 906 std::string extension3_id("3");
905 ExtensionWebRequestEventRouter::RequestFilter filter; 907 ExtensionWebRequestEventRouter::RequestFilter filter;
906 const std::string kEventName(keys::kOnBeforeSendHeadersEvent); 908 const std::string kEventName(keys::kOnBeforeSendHeadersEvent);
907 base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_); 909 base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
908 910
909 // Install two extensions that can modify headers. Extension 2 has 911 // Install two extensions that can modify headers. Extension 2 has
910 // higher precedence than extension 1. 912 // higher precedence than extension 1.
911 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 913 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
912 &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName, 914 &profile_, extension1_id, extension1_id, events::FOR_TEST, kEventName,
913 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0, 915 kEventName + "/1", filter, ExtraInfoSpec::BLOCKING, 0, 0,
914 ipc_sender_factory.GetWeakPtr()); 916 ipc_sender_factory.GetWeakPtr());
915 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 917 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
916 &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName, 918 &profile_, extension2_id, extension2_id, events::FOR_TEST, kEventName,
917 kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0, 919 kEventName + "/2", filter, ExtraInfoSpec::BLOCKING, 0, 0,
918 ipc_sender_factory.GetWeakPtr()); 920 ipc_sender_factory.GetWeakPtr());
919 921
920 // Install one extension that observes the final headers. 922 // Install one extension that observes the final headers.
921 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener( 923 ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
922 &profile_, extension3_id, extension3_id, events::FOR_TEST, 924 &profile_, extension3_id, extension3_id, events::FOR_TEST,
923 keys::kOnSendHeadersEvent, std::string(keys::kOnSendHeadersEvent) + "/3", 925 keys::kOnSendHeadersEvent, std::string(keys::kOnSendHeadersEvent) + "/3",
924 filter, ExtraInfoSpec::REQUEST_HEADERS, 0, 0, 926 filter, ExtraInfoSpec::REQUEST_HEADERS, 0, 0,
925 ipc_sender_factory.GetWeakPtr()); 927 ipc_sender_factory.GetWeakPtr());
926 928
927 GURL request_url("http://doesnotexist/does_not_exist.html"); 929 GURL request_url("http://doesnotexist/does_not_exist.html");
928 scoped_ptr<net::URLRequest> request(context_->CreateRequest( 930 std::unique_ptr<net::URLRequest> request(
929 request_url, net::DEFAULT_PRIORITY, &delegate_)); 931 context_->CreateRequest(request_url, net::DEFAULT_PRIORITY, &delegate_));
930 932
931 // Initialize headers available before extensions are notified of the 933 // Initialize headers available before extensions are notified of the
932 // onBeforeSendHeaders event. 934 // onBeforeSendHeaders event.
933 HeaderModificationTest test = GetParam(); 935 HeaderModificationTest test = GetParam();
934 net::HttpRequestHeaders before_headers; 936 net::HttpRequestHeaders before_headers;
935 for (int i = 0; i < test.before_size; ++i) 937 for (int i = 0; i < test.before_size; ++i)
936 before_headers.SetHeader(test.before[i].name, test.before[i].value); 938 before_headers.SetHeader(test.before[i].name, test.before[i].value);
937 request->SetExtraRequestHeaders(before_headers); 939 request->SetExtraRequestHeaders(before_headers);
938 940
939 // Gather the modifications to the headers for the respective extensions. 941 // Gather the modifications to the headers for the respective extensions.
(...skipping 322 matching lines...) Expand 10 before | Expand all | Expand 10 after
1262 base::ListValue list_value; 1264 base::ListValue list_value;
1263 list_value.Append(new base::FundamentalValue('1')); 1265 list_value.Append(new base::FundamentalValue('1'));
1264 list_value.Append(new base::FundamentalValue('2')); 1266 list_value.Append(new base::FundamentalValue('2'));
1265 list_value.Append(new base::FundamentalValue('3')); 1267 list_value.Append(new base::FundamentalValue('3'));
1266 list_value.Append(new base::FundamentalValue(0xFE)); 1268 list_value.Append(new base::FundamentalValue(0xFE));
1267 list_value.Append(new base::FundamentalValue(0xD1)); 1269 list_value.Append(new base::FundamentalValue(0xD1));
1268 1270
1269 unsigned char char_value[] = {'1', '2', '3', 0xFE, 0xD1}; 1271 unsigned char char_value[] = {'1', '2', '3', 0xFE, 0xD1};
1270 std::string string_value(reinterpret_cast<char *>(char_value), 5); 1272 std::string string_value(reinterpret_cast<char *>(char_value), 5);
1271 1273
1272 scoped_ptr<base::ListValue> converted_list(StringToCharList(string_value)); 1274 std::unique_ptr<base::ListValue> converted_list(
1275 StringToCharList(string_value));
1273 EXPECT_TRUE(list_value.Equals(converted_list.get())); 1276 EXPECT_TRUE(list_value.Equals(converted_list.get()));
1274 1277
1275 std::string converted_string; 1278 std::string converted_string;
1276 EXPECT_TRUE(CharListToString(&list_value, &converted_string)); 1279 EXPECT_TRUE(CharListToString(&list_value, &converted_string));
1277 EXPECT_EQ(string_value, converted_string); 1280 EXPECT_EQ(string_value, converted_string);
1278 } 1281 }
1279 1282
1280 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeRequestDelta) { 1283 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeRequestDelta) {
1281 const bool cancel = true; 1284 const bool cancel = true;
1282 const GURL localhost("http://localhost"); 1285 const GURL localhost("http://localhost");
1283 scoped_ptr<EventResponseDelta> delta( 1286 std::unique_ptr<EventResponseDelta> delta(CalculateOnBeforeRequestDelta(
1284 CalculateOnBeforeRequestDelta("extid", base::Time::Now(), 1287 "extid", base::Time::Now(), cancel, localhost));
1285 cancel, localhost));
1286 ASSERT_TRUE(delta.get()); 1288 ASSERT_TRUE(delta.get());
1287 EXPECT_TRUE(delta->cancel); 1289 EXPECT_TRUE(delta->cancel);
1288 EXPECT_EQ(localhost, delta->new_url); 1290 EXPECT_EQ(localhost, delta->new_url);
1289 } 1291 }
1290 1292
1291 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) { 1293 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnBeforeSendHeadersDelta) {
1292 const bool cancel = true; 1294 const bool cancel = true;
1293 std::string value; 1295 std::string value;
1294 net::HttpRequestHeaders old_headers; 1296 net::HttpRequestHeaders old_headers;
1295 old_headers.AddHeadersFromString("key1: value1\r\n" 1297 old_headers.AddHeadersFromString("key1: value1\r\n"
1296 "key2: value2\r\n"); 1298 "key2: value2\r\n");
1297 1299
1298 // Test adding a header. 1300 // Test adding a header.
1299 net::HttpRequestHeaders new_headers_added; 1301 net::HttpRequestHeaders new_headers_added;
1300 new_headers_added.AddHeadersFromString("key1: value1\r\n" 1302 new_headers_added.AddHeadersFromString("key1: value1\r\n"
1301 "key3: value3\r\n" 1303 "key3: value3\r\n"
1302 "key2: value2\r\n"); 1304 "key2: value2\r\n");
1303 scoped_ptr<EventResponseDelta> delta_added( 1305 std::unique_ptr<EventResponseDelta> delta_added(
1304 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel, 1306 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
1305 &old_headers, &new_headers_added)); 1307 &old_headers, &new_headers_added));
1306 ASSERT_TRUE(delta_added.get()); 1308 ASSERT_TRUE(delta_added.get());
1307 EXPECT_TRUE(delta_added->cancel); 1309 EXPECT_TRUE(delta_added->cancel);
1308 ASSERT_TRUE(delta_added->modified_request_headers.GetHeader("key3", &value)); 1310 ASSERT_TRUE(delta_added->modified_request_headers.GetHeader("key3", &value));
1309 EXPECT_EQ("value3", value); 1311 EXPECT_EQ("value3", value);
1310 1312
1311 // Test deleting a header. 1313 // Test deleting a header.
1312 net::HttpRequestHeaders new_headers_deleted; 1314 net::HttpRequestHeaders new_headers_deleted;
1313 new_headers_deleted.AddHeadersFromString("key1: value1\r\n"); 1315 new_headers_deleted.AddHeadersFromString("key1: value1\r\n");
1314 scoped_ptr<EventResponseDelta> delta_deleted( 1316 std::unique_ptr<EventResponseDelta> delta_deleted(
1315 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel, 1317 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
1316 &old_headers, &new_headers_deleted)); 1318 &old_headers, &new_headers_deleted));
1317 ASSERT_TRUE(delta_deleted.get()); 1319 ASSERT_TRUE(delta_deleted.get());
1318 ASSERT_EQ(1u, delta_deleted->deleted_request_headers.size()); 1320 ASSERT_EQ(1u, delta_deleted->deleted_request_headers.size());
1319 ASSERT_EQ("key2", delta_deleted->deleted_request_headers.front()); 1321 ASSERT_EQ("key2", delta_deleted->deleted_request_headers.front());
1320 1322
1321 // Test modifying a header. 1323 // Test modifying a header.
1322 net::HttpRequestHeaders new_headers_modified; 1324 net::HttpRequestHeaders new_headers_modified;
1323 new_headers_modified.AddHeadersFromString("key1: value1\r\n" 1325 new_headers_modified.AddHeadersFromString("key1: value1\r\n"
1324 "key2: value3\r\n"); 1326 "key2: value3\r\n");
1325 scoped_ptr<EventResponseDelta> delta_modified( 1327 std::unique_ptr<EventResponseDelta> delta_modified(
1326 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel, 1328 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
1327 &old_headers, &new_headers_modified)); 1329 &old_headers, &new_headers_modified));
1328 ASSERT_TRUE(delta_modified.get()); 1330 ASSERT_TRUE(delta_modified.get());
1329 EXPECT_TRUE(delta_modified->deleted_request_headers.empty()); 1331 EXPECT_TRUE(delta_modified->deleted_request_headers.empty());
1330 ASSERT_TRUE( 1332 ASSERT_TRUE(
1331 delta_modified->modified_request_headers.GetHeader("key2", &value)); 1333 delta_modified->modified_request_headers.GetHeader("key2", &value));
1332 EXPECT_EQ("value3", value); 1334 EXPECT_EQ("value3", value);
1333 1335
1334 // Test modifying a header if extension author just appended a new (key, 1336 // Test modifying a header if extension author just appended a new (key,
1335 // value) pair with a key that existed before. This is incorrect 1337 // value) pair with a key that existed before. This is incorrect
1336 // usage of the API that shall be handled gracefully. 1338 // usage of the API that shall be handled gracefully.
1337 net::HttpRequestHeaders new_headers_modified2; 1339 net::HttpRequestHeaders new_headers_modified2;
1338 new_headers_modified2.AddHeadersFromString("key1: value1\r\n" 1340 new_headers_modified2.AddHeadersFromString("key1: value1\r\n"
1339 "key2: value2\r\n" 1341 "key2: value2\r\n"
1340 "key2: value3\r\n"); 1342 "key2: value3\r\n");
1341 scoped_ptr<EventResponseDelta> delta_modified2( 1343 std::unique_ptr<EventResponseDelta> delta_modified2(
1342 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel, 1344 CalculateOnBeforeSendHeadersDelta("extid", base::Time::Now(), cancel,
1343 &old_headers, &new_headers_modified)); 1345 &old_headers, &new_headers_modified));
1344 ASSERT_TRUE(delta_modified2.get()); 1346 ASSERT_TRUE(delta_modified2.get());
1345 EXPECT_TRUE(delta_modified2->deleted_request_headers.empty()); 1347 EXPECT_TRUE(delta_modified2->deleted_request_headers.empty());
1346 ASSERT_TRUE( 1348 ASSERT_TRUE(
1347 delta_modified2->modified_request_headers.GetHeader("key2", &value)); 1349 delta_modified2->modified_request_headers.GetHeader("key2", &value));
1348 EXPECT_EQ("value3", value); 1350 EXPECT_EQ("value3", value);
1349 } 1351 }
1350 1352
1351 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) { 1353 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) {
1352 const bool cancel = true; 1354 const bool cancel = true;
1353 char base_headers_string[] = 1355 char base_headers_string[] =
1354 "HTTP/1.0 200 OK\r\n" 1356 "HTTP/1.0 200 OK\r\n"
1355 "Key1: Value1\r\n" 1357 "Key1: Value1\r\n"
1356 "Key2: Value2, Bar\r\n" 1358 "Key2: Value2, Bar\r\n"
1357 "Key3: Value3\r\n" 1359 "Key3: Value3\r\n"
1358 "Key5: Value5, end5\r\n" 1360 "Key5: Value5, end5\r\n"
1359 "\r\n"; 1361 "\r\n";
1360 scoped_refptr<net::HttpResponseHeaders> base_headers( 1362 scoped_refptr<net::HttpResponseHeaders> base_headers(
1361 new net::HttpResponseHeaders( 1363 new net::HttpResponseHeaders(
1362 net::HttpUtil::AssembleRawHeaders( 1364 net::HttpUtil::AssembleRawHeaders(
1363 base_headers_string, sizeof(base_headers_string)))); 1365 base_headers_string, sizeof(base_headers_string))));
1364 1366
1365 ResponseHeaders new_headers; 1367 ResponseHeaders new_headers;
1366 new_headers.push_back(ResponseHeader("kEy1", "Value1")); // Unchanged 1368 new_headers.push_back(ResponseHeader("kEy1", "Value1")); // Unchanged
1367 new_headers.push_back(ResponseHeader("Key2", "Value1")); // Modified 1369 new_headers.push_back(ResponseHeader("Key2", "Value1")); // Modified
1368 // Key3 is deleted 1370 // Key3 is deleted
1369 new_headers.push_back(ResponseHeader("Key4", "Value4")); // Added 1371 new_headers.push_back(ResponseHeader("Key4", "Value4")); // Added
1370 new_headers.push_back(ResponseHeader("Key5", "Value5, end5")); // Unchanged 1372 new_headers.push_back(ResponseHeader("Key5", "Value5, end5")); // Unchanged
1371 GURL effective_new_url; 1373 GURL effective_new_url;
1372 1374
1373 scoped_ptr<EventResponseDelta> delta( 1375 std::unique_ptr<EventResponseDelta> delta(CalculateOnHeadersReceivedDelta(
1374 CalculateOnHeadersReceivedDelta("extid", 1376 "extid", base::Time::Now(), cancel, effective_new_url, base_headers.get(),
1375 base::Time::Now(), 1377 &new_headers));
1376 cancel,
1377 effective_new_url,
1378 base_headers.get(),
1379 &new_headers));
1380 ASSERT_TRUE(delta.get()); 1378 ASSERT_TRUE(delta.get());
1381 EXPECT_TRUE(delta->cancel); 1379 EXPECT_TRUE(delta->cancel);
1382 EXPECT_EQ(2u, delta->added_response_headers.size()); 1380 EXPECT_EQ(2u, delta->added_response_headers.size());
1383 EXPECT_TRUE(Contains(delta->added_response_headers, 1381 EXPECT_TRUE(Contains(delta->added_response_headers,
1384 ResponseHeader("Key2", "Value1"))); 1382 ResponseHeader("Key2", "Value1")));
1385 EXPECT_TRUE(Contains(delta->added_response_headers, 1383 EXPECT_TRUE(Contains(delta->added_response_headers,
1386 ResponseHeader("Key4", "Value4"))); 1384 ResponseHeader("Key4", "Value4")));
1387 EXPECT_EQ(2u, delta->deleted_response_headers.size()); 1385 EXPECT_EQ(2u, delta->deleted_response_headers.size());
1388 EXPECT_TRUE(Contains(delta->deleted_response_headers, 1386 EXPECT_TRUE(Contains(delta->deleted_response_headers,
1389 ResponseHeader("Key2", "Value2, Bar"))); 1387 ResponseHeader("Key2", "Value2, Bar")));
1390 EXPECT_TRUE(Contains(delta->deleted_response_headers, 1388 EXPECT_TRUE(Contains(delta->deleted_response_headers,
1391 ResponseHeader("Key3", "Value3"))); 1389 ResponseHeader("Key3", "Value3")));
1392 } 1390 }
1393 1391
1394 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) { 1392 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
1395 const bool cancel = true; 1393 const bool cancel = true;
1396 1394
1397 base::string16 username = base::ASCIIToUTF16("foo"); 1395 base::string16 username = base::ASCIIToUTF16("foo");
1398 base::string16 password = base::ASCIIToUTF16("bar"); 1396 base::string16 password = base::ASCIIToUTF16("bar");
1399 scoped_ptr<net::AuthCredentials> credentials( 1397 std::unique_ptr<net::AuthCredentials> credentials(
1400 new net::AuthCredentials(username, password)); 1398 new net::AuthCredentials(username, password));
1401 1399
1402 scoped_ptr<EventResponseDelta> delta( 1400 std::unique_ptr<EventResponseDelta> delta(CalculateOnAuthRequiredDelta(
1403 CalculateOnAuthRequiredDelta("extid", base::Time::Now(), cancel, 1401 "extid", base::Time::Now(), cancel, &credentials));
1404 &credentials));
1405 ASSERT_TRUE(delta.get()); 1402 ASSERT_TRUE(delta.get());
1406 EXPECT_TRUE(delta->cancel); 1403 EXPECT_TRUE(delta->cancel);
1407 ASSERT_TRUE(delta->auth_credentials.get()); 1404 ASSERT_TRUE(delta->auth_credentials.get());
1408 EXPECT_EQ(username, delta->auth_credentials->username()); 1405 EXPECT_EQ(username, delta->auth_credentials->username());
1409 EXPECT_EQ(password, delta->auth_credentials->password()); 1406 EXPECT_EQ(password, delta->auth_credentials->password());
1410 } 1407 }
1411 1408
1412 TEST(ExtensionWebRequestHelpersTest, TestMergeCancelOfResponses) { 1409 TEST(ExtensionWebRequestHelpersTest, TestMergeCancelOfResponses) {
1413 EventResponseDeltas deltas; 1410 EventResponseDeltas deltas;
1414 net::BoundTestNetLog capturing_net_log; 1411 net::BoundTestNetLog capturing_net_log;
(...skipping 902 matching lines...) Expand 10 before | Expand all | Expand 10 after
2317 EXPECT_TRUE(credentials_set); 2314 EXPECT_TRUE(credentials_set);
2318 EXPECT_FALSE(auth3.Empty()); 2315 EXPECT_FALSE(auth3.Empty());
2319 EXPECT_EQ(username, auth1.username()); 2316 EXPECT_EQ(username, auth1.username());
2320 EXPECT_EQ(password, auth1.password()); 2317 EXPECT_EQ(password, auth1.password());
2321 EXPECT_EQ(1u, warning_set.size()); 2318 EXPECT_EQ(1u, warning_set.size());
2322 EXPECT_TRUE(HasWarning(warning_set, "extid2")); 2319 EXPECT_TRUE(HasWarning(warning_set, "extid2"));
2323 EXPECT_EQ(3u, capturing_net_log.GetSize()); 2320 EXPECT_EQ(3u, capturing_net_log.GetSize());
2324 } 2321 }
2325 2322
2326 } // namespace extensions 2323 } // namespace extensions
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698