OLD | NEW |
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 <queue> | 5 #include <queue> |
6 #include <map> | 6 #include <map> |
7 | 7 |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/file_util.h" | 10 #include "base/file_util.h" |
(...skipping 30 matching lines...) Expand all Loading... |
41 using helpers::CalculateOnBeforeRequestDelta; | 41 using helpers::CalculateOnBeforeRequestDelta; |
42 using helpers::CalculateOnBeforeSendHeadersDelta; | 42 using helpers::CalculateOnBeforeSendHeadersDelta; |
43 using helpers::CalculateOnHeadersReceivedDelta; | 43 using helpers::CalculateOnHeadersReceivedDelta; |
44 using helpers::CharListToString; | 44 using helpers::CharListToString; |
45 using helpers::EventResponseDelta; | 45 using helpers::EventResponseDelta; |
46 using helpers::EventResponseDeltas; | 46 using helpers::EventResponseDeltas; |
47 using helpers::EventResponseDeltas; | 47 using helpers::EventResponseDeltas; |
48 using helpers::InDecreasingExtensionInstallationTimeOrder; | 48 using helpers::InDecreasingExtensionInstallationTimeOrder; |
49 using helpers::MergeCancelOfResponses; | 49 using helpers::MergeCancelOfResponses; |
50 using helpers::MergeOnBeforeRequestResponses; | 50 using helpers::MergeOnBeforeRequestResponses; |
| 51 using helpers::RequestCookieModification; |
| 52 using helpers::ResponseCookieModification; |
51 using helpers::ResponseHeader; | 53 using helpers::ResponseHeader; |
52 using helpers::ResponseHeaders; | 54 using helpers::ResponseHeaders; |
53 using helpers::StringToCharList; | 55 using helpers::StringToCharList; |
54 | 56 |
55 namespace { | 57 namespace { |
56 static void EventHandledOnIOThread( | 58 static void EventHandledOnIOThread( |
57 void* profile, | 59 void* profile, |
58 const std::string& extension_id, | 60 const std::string& extension_id, |
59 const std::string& event_name, | 61 const std::string& event_name, |
60 const std::string& sub_event_name, | 62 const std::string& sub_event_name, |
(...skipping 1213 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1274 EXPECT_EQ("value 3", header_value); | 1276 EXPECT_EQ("value 3", header_value); |
1275 ASSERT_TRUE(headers3.GetHeader("key3", &header_value)); | 1277 ASSERT_TRUE(headers3.GetHeader("key3", &header_value)); |
1276 EXPECT_EQ("value 3", header_value); | 1278 EXPECT_EQ("value 3", header_value); |
1277 ASSERT_TRUE(headers3.GetHeader("key5", &header_value)); | 1279 ASSERT_TRUE(headers3.GetHeader("key5", &header_value)); |
1278 EXPECT_EQ("value 5", header_value); | 1280 EXPECT_EQ("value 5", header_value); |
1279 EXPECT_EQ(1u, conflicting_extensions.size()); | 1281 EXPECT_EQ(1u, conflicting_extensions.size()); |
1280 EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2")); | 1282 EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2")); |
1281 EXPECT_EQ(3u, capturing_net_log.GetSize()); | 1283 EXPECT_EQ(3u, capturing_net_log.GetSize()); |
1282 } | 1284 } |
1283 | 1285 |
| 1286 TEST(ExtensionWebRequestHelpersTest, |
| 1287 TestMergeOnBeforeSendHeadersResponses_Cookies) { |
| 1288 net::HttpRequestHeaders base_headers; |
| 1289 base_headers.AddHeaderFromString( |
| 1290 "Cookie: name=value; name2=value2; name3=value3"); |
| 1291 net::CapturingBoundNetLog capturing_net_log; |
| 1292 net::BoundNetLog net_log = capturing_net_log.bound(); |
| 1293 std::set<std::string> conflicting_extensions; |
| 1294 std::string header_value; |
| 1295 EventResponseDeltas deltas; |
| 1296 |
| 1297 linked_ptr<RequestCookieModification> add_cookie = |
| 1298 make_linked_ptr(new RequestCookieModification); |
| 1299 add_cookie->type = helpers::ADD; |
| 1300 add_cookie->modification.reset(new helpers::RequestCookie); |
| 1301 add_cookie->modification->name.reset(new std::string("name4")); |
| 1302 add_cookie->modification->value.reset(new std::string("\"value 4\"")); |
| 1303 |
| 1304 linked_ptr<RequestCookieModification> add_cookie_2 = |
| 1305 make_linked_ptr(new RequestCookieModification); |
| 1306 add_cookie_2->type = helpers::ADD; |
| 1307 add_cookie_2->modification.reset(new helpers::RequestCookie); |
| 1308 add_cookie_2->modification->name.reset(new std::string("name")); |
| 1309 add_cookie_2->modification->value.reset(new std::string("new value")); |
| 1310 |
| 1311 linked_ptr<RequestCookieModification> edit_cookie = |
| 1312 make_linked_ptr(new RequestCookieModification); |
| 1313 edit_cookie->type = helpers::EDIT; |
| 1314 edit_cookie->filter.reset(new helpers::RequestCookie); |
| 1315 edit_cookie->filter->name.reset(new std::string("name2")); |
| 1316 edit_cookie->modification.reset(new helpers::RequestCookie); |
| 1317 edit_cookie->modification->value.reset(new std::string("new value")); |
| 1318 |
| 1319 linked_ptr<RequestCookieModification> remove_cookie = |
| 1320 make_linked_ptr(new RequestCookieModification); |
| 1321 remove_cookie->type = helpers::REMOVE; |
| 1322 remove_cookie->filter.reset(new helpers::RequestCookie); |
| 1323 remove_cookie->filter->name.reset(new std::string("name3")); |
| 1324 |
| 1325 linked_ptr<RequestCookieModification> operations[] = { |
| 1326 add_cookie, add_cookie_2, edit_cookie, remove_cookie |
| 1327 }; |
| 1328 |
| 1329 for (size_t i = 0; i < arraysize(operations); ++i) { |
| 1330 linked_ptr<EventResponseDelta> delta( |
| 1331 new EventResponseDelta("extid0", base::Time::FromInternalValue(i * 5))); |
| 1332 delta->request_cookie_modifications.push_back(operations[i]); |
| 1333 deltas.push_back(delta); |
| 1334 } |
| 1335 deltas.sort(&InDecreasingExtensionInstallationTimeOrder); |
| 1336 net::HttpRequestHeaders headers1; |
| 1337 headers1.MergeFrom(base_headers); |
| 1338 MergeOnBeforeSendHeadersResponses( |
| 1339 deltas, &headers1, &conflicting_extensions, &net_log); |
| 1340 EXPECT_TRUE(headers1.HasHeader("Cookie")); |
| 1341 ASSERT_TRUE(headers1.GetHeader("Cookie", &header_value)); |
| 1342 EXPECT_EQ("name=new value; name2=new value; name4=\"value 4\"", header_value); |
| 1343 EXPECT_EQ(0u, conflicting_extensions.size()); |
| 1344 EXPECT_EQ(0u, capturing_net_log.GetSize()); |
| 1345 } |
| 1346 |
| 1347 TEST(ExtensionWebRequestHelpersTest, |
| 1348 TestMergeCookiesInOnHeadersReceivedResponses) { |
| 1349 net::CapturingBoundNetLog capturing_net_log; |
| 1350 net::BoundNetLog net_log = capturing_net_log.bound(); |
| 1351 std::set<std::string> conflicting_extensions; |
| 1352 std::string header_value; |
| 1353 EventResponseDeltas deltas; |
| 1354 |
| 1355 char base_headers_string[] = |
| 1356 "HTTP/1.0 200 OK\r\n" |
| 1357 "Foo: Bar\r\n" |
| 1358 "Set-Cookie: name=value; DOMAIN=google.com; Secure\r\n" |
| 1359 "Set-Cookie: name2=value2\r\n" |
| 1360 "Set-Cookie: name3=value3\r\n" |
| 1361 "\r\n"; |
| 1362 scoped_refptr<net::HttpResponseHeaders> base_headers( |
| 1363 new net::HttpResponseHeaders( |
| 1364 net::HttpUtil::AssembleRawHeaders( |
| 1365 base_headers_string, sizeof(base_headers_string)))); |
| 1366 |
| 1367 // Check that we can handle if not touching the response headers. |
| 1368 linked_ptr<EventResponseDelta> d0( |
| 1369 new EventResponseDelta("extid0", base::Time::FromInternalValue(3000))); |
| 1370 deltas.push_back(d0); |
| 1371 scoped_refptr<net::HttpResponseHeaders> new_headers0; |
| 1372 MergeCookiesInOnHeadersReceivedResponses( |
| 1373 deltas, base_headers.get(), &new_headers0, &conflicting_extensions, |
| 1374 &net_log); |
| 1375 EXPECT_FALSE(new_headers0.get()); |
| 1376 EXPECT_EQ(0u, conflicting_extensions.size()); |
| 1377 EXPECT_EQ(0u, capturing_net_log.GetSize()); |
| 1378 |
| 1379 linked_ptr<ResponseCookieModification> add_cookie = |
| 1380 make_linked_ptr(new ResponseCookieModification); |
| 1381 add_cookie->type = helpers::ADD; |
| 1382 add_cookie->modification.reset(new helpers::ResponseCookie); |
| 1383 add_cookie->modification->name.reset(new std::string("name4")); |
| 1384 add_cookie->modification->value.reset(new std::string("\"value4\"")); |
| 1385 |
| 1386 linked_ptr<ResponseCookieModification> edit_cookie = |
| 1387 make_linked_ptr(new ResponseCookieModification); |
| 1388 edit_cookie->type = helpers::EDIT; |
| 1389 edit_cookie->filter.reset(new helpers::ResponseCookie); |
| 1390 edit_cookie->filter->name.reset(new std::string("name2")); |
| 1391 edit_cookie->modification.reset(new helpers::ResponseCookie); |
| 1392 edit_cookie->modification->value.reset(new std::string("new value")); |
| 1393 |
| 1394 linked_ptr<ResponseCookieModification> edit_cookie_2 = |
| 1395 make_linked_ptr(new ResponseCookieModification); |
| 1396 edit_cookie_2->type = helpers::EDIT; |
| 1397 edit_cookie_2->filter.reset(new helpers::ResponseCookie); |
| 1398 edit_cookie_2->filter->secure.reset(new bool(false)); |
| 1399 edit_cookie_2->modification.reset(new helpers::ResponseCookie); |
| 1400 edit_cookie_2->modification->secure.reset(new bool(true)); |
| 1401 |
| 1402 linked_ptr<ResponseCookieModification> remove_cookie = |
| 1403 make_linked_ptr(new ResponseCookieModification); |
| 1404 remove_cookie->type = helpers::REMOVE; |
| 1405 remove_cookie->filter.reset(new helpers::ResponseCookie); |
| 1406 remove_cookie->filter->name.reset(new std::string("name3")); |
| 1407 |
| 1408 linked_ptr<ResponseCookieModification> operations[] = { |
| 1409 add_cookie, edit_cookie, edit_cookie_2, remove_cookie |
| 1410 }; |
| 1411 |
| 1412 for (size_t i = 0; i < arraysize(operations); ++i) { |
| 1413 linked_ptr<EventResponseDelta> delta( |
| 1414 new EventResponseDelta("extid0", base::Time::FromInternalValue(i * 5))); |
| 1415 delta->response_cookie_modifications.push_back(operations[i]); |
| 1416 deltas.push_back(delta); |
| 1417 } |
| 1418 deltas.sort(&InDecreasingExtensionInstallationTimeOrder); |
| 1419 scoped_refptr<net::HttpResponseHeaders> headers1( |
| 1420 new net::HttpResponseHeaders( |
| 1421 net::HttpUtil::AssembleRawHeaders( |
| 1422 base_headers_string, sizeof(base_headers_string)))); |
| 1423 scoped_refptr<net::HttpResponseHeaders> new_headers1; |
| 1424 MergeCookiesInOnHeadersReceivedResponses( |
| 1425 deltas, headers1.get(), &new_headers1, &conflicting_extensions, &net_log); |
| 1426 |
| 1427 EXPECT_TRUE(new_headers1->HasHeader("Foo")); |
| 1428 void* iter = NULL; |
| 1429 std::string cookie_string; |
| 1430 std::set<std::string> expected_cookies; |
| 1431 expected_cookies.insert("name=value; domain=google.com; secure"); |
| 1432 expected_cookies.insert("name2=value2; secure"); |
| 1433 expected_cookies.insert("name4=\"value4\"; secure"); |
| 1434 std::set<std::string> actual_cookies; |
| 1435 while (new_headers1->EnumerateHeader(&iter, "Set-Cookie", &cookie_string)) |
| 1436 actual_cookies.insert(cookie_string); |
| 1437 EXPECT_EQ(expected_cookies, actual_cookies); |
| 1438 EXPECT_EQ(0u, conflicting_extensions.size()); |
| 1439 EXPECT_EQ(0u, capturing_net_log.GetSize()); |
| 1440 } |
| 1441 |
1284 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) { | 1442 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) { |
1285 net::CapturingBoundNetLog capturing_net_log; | 1443 net::CapturingBoundNetLog capturing_net_log; |
1286 net::BoundNetLog net_log = capturing_net_log.bound(); | 1444 net::BoundNetLog net_log = capturing_net_log.bound(); |
1287 std::set<std::string> conflicting_extensions; | 1445 std::set<std::string> conflicting_extensions; |
1288 std::string header_value; | 1446 std::string header_value; |
1289 EventResponseDeltas deltas; | 1447 EventResponseDeltas deltas; |
1290 | 1448 |
1291 char base_headers_string[] = | 1449 char base_headers_string[] = |
1292 "HTTP/1.0 200 OK\r\n" | 1450 "HTTP/1.0 200 OK\r\n" |
1293 "Key1: Value1\r\n" | 1451 "Key1: Value1\r\n" |
(...skipping 188 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1482 deltas, &auth3, &conflicting_extensions, &net_log); | 1640 deltas, &auth3, &conflicting_extensions, &net_log); |
1483 EXPECT_TRUE(credentials_set); | 1641 EXPECT_TRUE(credentials_set); |
1484 EXPECT_FALSE(auth3.Empty()); | 1642 EXPECT_FALSE(auth3.Empty()); |
1485 EXPECT_EQ(username, auth1.username()); | 1643 EXPECT_EQ(username, auth1.username()); |
1486 EXPECT_EQ(password, auth1.password()); | 1644 EXPECT_EQ(password, auth1.password()); |
1487 EXPECT_EQ(1u, conflicting_extensions.size()); | 1645 EXPECT_EQ(1u, conflicting_extensions.size()); |
1488 EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2")); | 1646 EXPECT_TRUE(ContainsKey(conflicting_extensions, "extid2")); |
1489 EXPECT_EQ(3u, capturing_net_log.GetSize()); | 1647 EXPECT_EQ(3u, capturing_net_log.GetSize()); |
1490 } | 1648 } |
1491 | 1649 |
OLD | NEW |