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

Side by Side Diff: net/http/http_network_transaction_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 2 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 2013 The Chromium Authors. All rights reserved. 1 // Copyright 2013 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/http/http_network_transaction.h" 5 #include "net/http/http_network_transaction.h"
6 6
7 #include <math.h> // ceil 7 #include <math.h> // ceil
8 #include <stdarg.h> 8 #include <stdarg.h>
9 #include <stdint.h> 9 #include <stdint.h>
10 10
(...skipping 526 matching lines...) Expand 10 before | Expand all | Expand 10 after
537 const std::string last_group_name_received() const { 537 const std::string last_group_name_received() const {
538 return last_group_name_; 538 return last_group_name_;
539 } 539 }
540 540
541 int RequestSocket(const std::string& group_name, 541 int RequestSocket(const std::string& group_name,
542 const void* socket_params, 542 const void* socket_params,
543 RequestPriority priority, 543 RequestPriority priority,
544 ClientSocketPool::RespectLimits respect_limits, 544 ClientSocketPool::RespectLimits respect_limits,
545 ClientSocketHandle* handle, 545 ClientSocketHandle* handle,
546 const CompletionCallback& callback, 546 const CompletionCallback& callback,
547 const BoundNetLog& net_log) override { 547 const NetLogWithSource& net_log) override {
548 last_group_name_ = group_name; 548 last_group_name_ = group_name;
549 return ERR_IO_PENDING; 549 return ERR_IO_PENDING;
550 } 550 }
551 void CancelRequest(const std::string& group_name, 551 void CancelRequest(const std::string& group_name,
552 ClientSocketHandle* handle) override {} 552 ClientSocketHandle* handle) override {}
553 void ReleaseSocket(const std::string& group_name, 553 void ReleaseSocket(const std::string& group_name,
554 std::unique_ptr<StreamSocket> socket, 554 std::unique_ptr<StreamSocket> socket,
555 int id) override {} 555 int id) override {}
556 void CloseIdleSockets() override {} 556 void CloseIdleSockets() override {}
557 int IdleSocketCount() const override { return 0; } 557 int IdleSocketCount() const override { return 0; }
(...skipping 161 matching lines...) Expand 10 before | Expand all | Expand 10 after
719 719
720 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 720 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
721 721
722 std::unique_ptr<HttpTransaction> trans( 722 std::unique_ptr<HttpTransaction> trans(
723 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 723 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
724 724
725 HttpRequestInfo request; 725 HttpRequestInfo request;
726 request.method = "GET"; 726 request.method = "GET";
727 request.url = GURL("http://www.example.com:2000/"); 727 request.url = GURL("http://www.example.com:2000/");
728 TestCompletionCallback callback; 728 TestCompletionCallback callback;
729 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 729 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
730 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_INVALID_HTTP_RESPONSE)); 730 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_INVALID_HTTP_RESPONSE));
731 } 731 }
732 732
733 // Response with no status line, and a weird port. Option to allow weird ports 733 // Response with no status line, and a weird port. Option to allow weird ports
734 // enabled. 734 // enabled.
735 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeadersWeirdPortAllowed) { 735 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeadersWeirdPortAllowed) {
736 MockRead data_reads[] = { 736 MockRead data_reads[] = {
737 MockRead("hello world"), MockRead(SYNCHRONOUS, OK), 737 MockRead("hello world"), MockRead(SYNCHRONOUS, OK),
738 }; 738 };
739 739
740 StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0); 740 StaticSocketDataProvider data(data_reads, arraysize(data_reads), nullptr, 0);
741 session_deps_.socket_factory->AddSocketDataProvider(&data); 741 session_deps_.socket_factory->AddSocketDataProvider(&data);
742 session_deps_.http_09_on_non_default_ports_enabled = true; 742 session_deps_.http_09_on_non_default_ports_enabled = true;
743 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 743 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
744 744
745 std::unique_ptr<HttpTransaction> trans( 745 std::unique_ptr<HttpTransaction> trans(
746 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 746 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
747 747
748 HttpRequestInfo request; 748 HttpRequestInfo request;
749 request.method = "GET"; 749 request.method = "GET";
750 request.url = GURL("http://www.example.com:2000/"); 750 request.url = GURL("http://www.example.com:2000/");
751 TestCompletionCallback callback; 751 TestCompletionCallback callback;
752 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 752 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
753 EXPECT_THAT(callback.GetResult(rv), IsOk()); 753 EXPECT_THAT(callback.GetResult(rv), IsOk());
754 754
755 const HttpResponseInfo* info = trans->GetResponseInfo(); 755 const HttpResponseInfo* info = trans->GetResponseInfo();
756 ASSERT_TRUE(info->headers); 756 ASSERT_TRUE(info->headers);
757 EXPECT_EQ("HTTP/0.9 200 OK", info->headers->GetStatusLine()); 757 EXPECT_EQ("HTTP/0.9 200 OK", info->headers->GetStatusLine());
758 758
759 // Don't bother to read the body - that's verified elsewhere, important thing 759 // Don't bother to read the body - that's verified elsewhere, important thing
760 // is that the option to allow HTTP/0.9 on non-default ports is respected. 760 // is that the option to allow HTTP/0.9 on non-default ports is respected.
761 } 761 }
762 762
(...skipping 281 matching lines...) Expand 10 before | Expand all | Expand 10 after
1044 request.load_flags = 0; 1044 request.load_flags = 0;
1045 1045
1046 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 1046 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
1047 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 1047 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
1048 1048
1049 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1049 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1050 session_deps_.socket_factory->AddSocketDataProvider(&data); 1050 session_deps_.socket_factory->AddSocketDataProvider(&data);
1051 1051
1052 TestCompletionCallback callback; 1052 TestCompletionCallback callback;
1053 1053
1054 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1054 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1055 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1055 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1056 1056
1057 EXPECT_THAT(callback.WaitForResult(), IsOk()); 1057 EXPECT_THAT(callback.WaitForResult(), IsOk());
1058 1058
1059 const HttpResponseInfo* response = trans.GetResponseInfo(); 1059 const HttpResponseInfo* response = trans.GetResponseInfo();
1060 ASSERT_TRUE(response); 1060 ASSERT_TRUE(response);
1061 ASSERT_TRUE(response->headers); 1061 ASSERT_TRUE(response->headers);
1062 EXPECT_EQ("HTTP/1.1 302 Redirect", response->headers->GetStatusLine()); 1062 EXPECT_EQ("HTTP/1.1 302 Redirect", response->headers->GetStatusLine());
1063 std::string url; 1063 std::string url;
1064 EXPECT_TRUE(response->headers->IsRedirect(&url)); 1064 EXPECT_TRUE(response->headers->IsRedirect(&url));
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
1107 // No response body because the test stops reading here. 1107 // No response body because the test stops reading here.
1108 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), 1108 MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
1109 }; 1109 };
1110 1110
1111 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 1111 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
1112 data_writes1, arraysize(data_writes1)); 1112 data_writes1, arraysize(data_writes1));
1113 session_deps_.socket_factory->AddSocketDataProvider(&data1); 1113 session_deps_.socket_factory->AddSocketDataProvider(&data1);
1114 1114
1115 TestCompletionCallback callback1; 1115 TestCompletionCallback callback1;
1116 1116
1117 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 1117 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
1118 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1118 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1119 1119
1120 rv = callback1.WaitForResult(); 1120 rv = callback1.WaitForResult();
1121 EXPECT_THAT(rv, IsOk()); 1121 EXPECT_THAT(rv, IsOk());
1122 1122
1123 const HttpResponseInfo* response = trans.GetResponseInfo(); 1123 const HttpResponseInfo* response = trans.GetResponseInfo();
1124 ASSERT_TRUE(response); 1124 ASSERT_TRUE(response);
1125 1125
1126 // Check that the headers got parsed. 1126 // Check that the headers got parsed.
1127 EXPECT_TRUE(response->headers); 1127 EXPECT_TRUE(response->headers);
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
1166 for (int i = 0; i < 2; ++i) { 1166 for (int i = 0; i < 2; ++i) {
1167 HttpRequestInfo request; 1167 HttpRequestInfo request;
1168 request.method = "GET"; 1168 request.method = "GET";
1169 request.url = GURL("http://www.example.org/"); 1169 request.url = GURL("http://www.example.org/");
1170 request.load_flags = 0; 1170 request.load_flags = 0;
1171 1171
1172 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 1172 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
1173 1173
1174 TestCompletionCallback callback; 1174 TestCompletionCallback callback;
1175 1175
1176 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1176 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1177 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1177 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1178 1178
1179 rv = callback.WaitForResult(); 1179 rv = callback.WaitForResult();
1180 EXPECT_THAT(rv, IsOk()); 1180 EXPECT_THAT(rv, IsOk());
1181 1181
1182 const HttpResponseInfo* response = trans.GetResponseInfo(); 1182 const HttpResponseInfo* response = trans.GetResponseInfo();
1183 ASSERT_TRUE(response); 1183 ASSERT_TRUE(response);
1184 1184
1185 EXPECT_TRUE(response->headers); 1185 EXPECT_TRUE(response->headers);
1186 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 1186 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
(...skipping 30 matching lines...) Expand all
1217 MockRead("HTTP/1.0 100 Continue\r\n\r\n"), 1217 MockRead("HTTP/1.0 100 Continue\r\n\r\n"),
1218 MockRead("HTTP/1.0 200 OK\r\n\r\n"), 1218 MockRead("HTTP/1.0 200 OK\r\n\r\n"),
1219 MockRead("hello world"), 1219 MockRead("hello world"),
1220 MockRead(SYNCHRONOUS, OK), 1220 MockRead(SYNCHRONOUS, OK),
1221 }; 1221 };
1222 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1222 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1223 session_deps_.socket_factory->AddSocketDataProvider(&data); 1223 session_deps_.socket_factory->AddSocketDataProvider(&data);
1224 1224
1225 TestCompletionCallback callback; 1225 TestCompletionCallback callback;
1226 1226
1227 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1227 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1228 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1228 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1229 1229
1230 rv = callback.WaitForResult(); 1230 rv = callback.WaitForResult();
1231 EXPECT_THAT(rv, IsOk()); 1231 EXPECT_THAT(rv, IsOk());
1232 1232
1233 const HttpResponseInfo* response = trans.GetResponseInfo(); 1233 const HttpResponseInfo* response = trans.GetResponseInfo();
1234 ASSERT_TRUE(response); 1234 ASSERT_TRUE(response);
1235 1235
1236 EXPECT_TRUE(response->headers); 1236 EXPECT_TRUE(response->headers);
1237 EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine()); 1237 EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
(...skipping 20 matching lines...) Expand all
1258 MockRead("HTTP/1.1 102 Unspecified status code\r\n\r\n" 1258 MockRead("HTTP/1.1 102 Unspecified status code\r\n\r\n"
1259 "HTTP/1.1 200 OK\r\n\r\n"), 1259 "HTTP/1.1 200 OK\r\n\r\n"),
1260 MockRead("hello world"), 1260 MockRead("hello world"),
1261 MockRead(SYNCHRONOUS, OK), 1261 MockRead(SYNCHRONOUS, OK),
1262 }; 1262 };
1263 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1263 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1264 session_deps_.socket_factory->AddSocketDataProvider(&data); 1264 session_deps_.socket_factory->AddSocketDataProvider(&data);
1265 1265
1266 TestCompletionCallback callback; 1266 TestCompletionCallback callback;
1267 1267
1268 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1268 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1269 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1269 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1270 1270
1271 rv = callback.WaitForResult(); 1271 rv = callback.WaitForResult();
1272 EXPECT_THAT(rv, IsOk()); 1272 EXPECT_THAT(rv, IsOk());
1273 1273
1274 const HttpResponseInfo* response = trans.GetResponseInfo(); 1274 const HttpResponseInfo* response = trans.GetResponseInfo();
1275 ASSERT_TRUE(response); 1275 ASSERT_TRUE(response);
1276 1276
1277 EXPECT_TRUE(response->headers); 1277 EXPECT_TRUE(response->headers);
1278 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 1278 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
(...skipping 15 matching lines...) Expand all
1294 1294
1295 MockRead data_reads[] = { 1295 MockRead data_reads[] = {
1296 MockRead(SYNCHRONOUS, "HTTP/1.0 100 Continue\r\n"), 1296 MockRead(SYNCHRONOUS, "HTTP/1.0 100 Continue\r\n"),
1297 MockRead(ASYNC, 0), 1297 MockRead(ASYNC, 0),
1298 }; 1298 };
1299 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1299 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1300 session_deps_.socket_factory->AddSocketDataProvider(&data); 1300 session_deps_.socket_factory->AddSocketDataProvider(&data);
1301 1301
1302 TestCompletionCallback callback; 1302 TestCompletionCallback callback;
1303 1303
1304 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1304 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1305 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1305 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1306 1306
1307 rv = callback.WaitForResult(); 1307 rv = callback.WaitForResult();
1308 EXPECT_THAT(rv, IsOk()); 1308 EXPECT_THAT(rv, IsOk());
1309 1309
1310 std::string response_data; 1310 std::string response_data;
1311 rv = ReadTransaction(&trans, &response_data); 1311 rv = ReadTransaction(&trans, &response_data);
1312 EXPECT_THAT(rv, IsOk()); 1312 EXPECT_THAT(rv, IsOk());
1313 EXPECT_EQ("", response_data); 1313 EXPECT_EQ("", response_data);
1314 } 1314 }
1315 1315
1316 TEST_F(HttpNetworkTransactionTest, EmptyResponse) { 1316 TEST_F(HttpNetworkTransactionTest, EmptyResponse) {
1317 HttpRequestInfo request; 1317 HttpRequestInfo request;
1318 request.method = "POST"; 1318 request.method = "POST";
1319 request.url = GURL("http://www.foo.com/"); 1319 request.url = GURL("http://www.foo.com/");
1320 request.load_flags = 0; 1320 request.load_flags = 0;
1321 1321
1322 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 1322 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
1323 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 1323 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
1324 1324
1325 MockRead data_reads[] = { 1325 MockRead data_reads[] = {
1326 MockRead(ASYNC, 0), 1326 MockRead(ASYNC, 0),
1327 }; 1327 };
1328 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1328 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1329 session_deps_.socket_factory->AddSocketDataProvider(&data); 1329 session_deps_.socket_factory->AddSocketDataProvider(&data);
1330 1330
1331 TestCompletionCallback callback; 1331 TestCompletionCallback callback;
1332 1332
1333 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1333 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1334 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1334 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1335 1335
1336 rv = callback.WaitForResult(); 1336 rv = callback.WaitForResult();
1337 EXPECT_THAT(rv, IsError(ERR_EMPTY_RESPONSE)); 1337 EXPECT_THAT(rv, IsError(ERR_EMPTY_RESPONSE));
1338 } 1338 }
1339 1339
1340 void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest( 1340 void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
1341 const MockWrite* write_failure, 1341 const MockWrite* write_failure,
1342 const MockRead* read_failure) { 1342 const MockRead* read_failure) {
1343 HttpRequestInfo request; 1343 HttpRequestInfo request;
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
1389 const char* const kExpectedResponseData[] = { 1389 const char* const kExpectedResponseData[] = {
1390 "hello", "world" 1390 "hello", "world"
1391 }; 1391 };
1392 1392
1393 uint32_t first_socket_log_id = NetLog::Source::kInvalidId; 1393 uint32_t first_socket_log_id = NetLog::Source::kInvalidId;
1394 for (int i = 0; i < 2; ++i) { 1394 for (int i = 0; i < 2; ++i) {
1395 TestCompletionCallback callback; 1395 TestCompletionCallback callback;
1396 1396
1397 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 1397 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
1398 1398
1399 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1399 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1400 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1400 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1401 1401
1402 rv = callback.WaitForResult(); 1402 rv = callback.WaitForResult();
1403 EXPECT_THAT(rv, IsOk()); 1403 EXPECT_THAT(rv, IsOk());
1404 1404
1405 LoadTimingInfo load_timing_info; 1405 LoadTimingInfo load_timing_info;
1406 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 1406 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
1407 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 1407 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
1408 if (i == 0) { 1408 if (i == 0) {
1409 first_socket_log_id = load_timing_info.socket_log_id; 1409 first_socket_log_id = load_timing_info.socket_log_id;
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after
1509 // Wait for the preconnect to complete. 1509 // Wait for the preconnect to complete.
1510 // TODO(davidben): Some way to wait for an idle socket count might be handy. 1510 // TODO(davidben): Some way to wait for an idle socket count might be handy.
1511 base::RunLoop().RunUntilIdle(); 1511 base::RunLoop().RunUntilIdle();
1512 EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get())); 1512 EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
1513 1513
1514 // Make the request. 1514 // Make the request.
1515 TestCompletionCallback callback; 1515 TestCompletionCallback callback;
1516 1516
1517 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 1517 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
1518 1518
1519 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1519 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1520 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1520 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1521 1521
1522 rv = callback.WaitForResult(); 1522 rv = callback.WaitForResult();
1523 EXPECT_THAT(rv, IsOk()); 1523 EXPECT_THAT(rv, IsOk());
1524 1524
1525 LoadTimingInfo load_timing_info; 1525 LoadTimingInfo load_timing_info;
1526 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 1526 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
1527 TestLoadTimingNotReused( 1527 TestLoadTimingNotReused(
1528 load_timing_info, 1528 load_timing_info,
1529 CONNECT_TIMING_HAS_DNS_TIMES|CONNECT_TIMING_HAS_SSL_TIMES); 1529 CONNECT_TIMING_HAS_DNS_TIMES|CONNECT_TIMING_HAS_SSL_TIMES);
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after
1635 MockRead(ASYNC, ERR_CONNECTION_RESET), 1635 MockRead(ASYNC, ERR_CONNECTION_RESET),
1636 MockRead("HTTP/1.0 200 OK\r\n\r\n"), // Should not be used 1636 MockRead("HTTP/1.0 200 OK\r\n\r\n"), // Should not be used
1637 MockRead("hello world"), 1637 MockRead("hello world"),
1638 MockRead(SYNCHRONOUS, OK), 1638 MockRead(SYNCHRONOUS, OK),
1639 }; 1639 };
1640 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1640 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1641 session_deps_.socket_factory->AddSocketDataProvider(&data); 1641 session_deps_.socket_factory->AddSocketDataProvider(&data);
1642 1642
1643 TestCompletionCallback callback; 1643 TestCompletionCallback callback;
1644 1644
1645 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1645 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1646 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1646 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1647 1647
1648 rv = callback.WaitForResult(); 1648 rv = callback.WaitForResult();
1649 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 1649 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
1650 1650
1651 IPEndPoint endpoint; 1651 IPEndPoint endpoint;
1652 EXPECT_TRUE(trans.GetRemoteEndpoint(&endpoint)); 1652 EXPECT_TRUE(trans.GetRemoteEndpoint(&endpoint));
1653 EXPECT_LT(0u, endpoint.address().size()); 1653 EXPECT_LT(0u, endpoint.address().size());
1654 } 1654 }
1655 1655
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1693 MockRead("Connection: keep-alive\r\n"), 1693 MockRead("Connection: keep-alive\r\n"),
1694 MockRead("Content-Length: 100\r\n\r\n"), 1694 MockRead("Content-Length: 100\r\n\r\n"),
1695 MockRead("hello"), 1695 MockRead("hello"),
1696 MockRead(SYNCHRONOUS, 0), 1696 MockRead(SYNCHRONOUS, 0),
1697 }; 1697 };
1698 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1698 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1699 session_deps_.socket_factory->AddSocketDataProvider(&data); 1699 session_deps_.socket_factory->AddSocketDataProvider(&data);
1700 1700
1701 TestCompletionCallback callback; 1701 TestCompletionCallback callback;
1702 1702
1703 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 1703 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
1704 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1704 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1705 1705
1706 rv = callback.WaitForResult(); 1706 rv = callback.WaitForResult();
1707 EXPECT_THAT(rv, IsOk()); 1707 EXPECT_THAT(rv, IsOk());
1708 1708
1709 scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100)); 1709 scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100));
1710 rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback()); 1710 rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
1711 if (rv == ERR_IO_PENDING) 1711 if (rv == ERR_IO_PENDING)
1712 rv = callback.WaitForResult(); 1712 rv = callback.WaitForResult();
1713 EXPECT_EQ(5, rv); 1713 EXPECT_EQ(5, rv);
(...skipping 19 matching lines...) Expand all
1733 MockRead("HTTP/1.0 200 OK\r\n"), 1733 MockRead("HTTP/1.0 200 OK\r\n"),
1734 MockRead("Connection: keep-alive\r\n"), 1734 MockRead("Connection: keep-alive\r\n"),
1735 MockRead("Content-Length: 100\r\n\r\n"), 1735 MockRead("Content-Length: 100\r\n\r\n"),
1736 MockRead(SYNCHRONOUS, 0), 1736 MockRead(SYNCHRONOUS, 0),
1737 }; 1737 };
1738 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 1738 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
1739 session_deps_.socket_factory->AddSocketDataProvider(&data); 1739 session_deps_.socket_factory->AddSocketDataProvider(&data);
1740 1740
1741 TestCompletionCallback callback; 1741 TestCompletionCallback callback;
1742 1742
1743 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 1743 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
1744 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1744 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1745 1745
1746 rv = callback.WaitForResult(); 1746 rv = callback.WaitForResult();
1747 EXPECT_THAT(rv, IsOk()); 1747 EXPECT_THAT(rv, IsOk());
1748 1748
1749 scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100)); 1749 scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(100));
1750 rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback()); 1750 rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
1751 if (rv == ERR_IO_PENDING) 1751 if (rv == ERR_IO_PENDING)
1752 rv = callback.WaitForResult(); 1752 rv = callback.WaitForResult();
1753 EXPECT_THAT(rv, IsError(ERR_CONTENT_LENGTH_MISMATCH)); 1753 EXPECT_THAT(rv, IsError(ERR_CONTENT_LENGTH_MISMATCH));
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after
1830 const int kNumUnreadBodies = arraysize(data_writes) - 1; 1830 const int kNumUnreadBodies = arraysize(data_writes) - 1;
1831 std::string response_lines[kNumUnreadBodies]; 1831 std::string response_lines[kNumUnreadBodies];
1832 1832
1833 uint32_t first_socket_log_id = NetLog::Source::kInvalidId; 1833 uint32_t first_socket_log_id = NetLog::Source::kInvalidId;
1834 for (size_t i = 0; i < kNumUnreadBodies; ++i) { 1834 for (size_t i = 0; i < kNumUnreadBodies; ++i) {
1835 TestCompletionCallback callback; 1835 TestCompletionCallback callback;
1836 1836
1837 std::unique_ptr<HttpNetworkTransaction> trans( 1837 std::unique_ptr<HttpNetworkTransaction> trans(
1838 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 1838 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
1839 1839
1840 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 1840 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
1841 EXPECT_THAT(callback.GetResult(rv), IsOk()); 1841 EXPECT_THAT(callback.GetResult(rv), IsOk());
1842 1842
1843 LoadTimingInfo load_timing_info; 1843 LoadTimingInfo load_timing_info;
1844 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info)); 1844 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
1845 if (i == 0) { 1845 if (i == 0) {
1846 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 1846 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
1847 first_socket_log_id = load_timing_info.socket_log_id; 1847 first_socket_log_id = load_timing_info.socket_log_id;
1848 } else { 1848 } else {
1849 TestLoadTimingReused(load_timing_info); 1849 TestLoadTimingReused(load_timing_info);
1850 EXPECT_EQ(first_socket_log_id, load_timing_info.socket_log_id); 1850 EXPECT_EQ(first_socket_log_id, load_timing_info.socket_log_id);
(...skipping 24 matching lines...) Expand all
1875 }; 1875 };
1876 1876
1877 static_assert(kNumUnreadBodies == arraysize(kStatusLines), 1877 static_assert(kNumUnreadBodies == arraysize(kStatusLines),
1878 "forgot to update kStatusLines"); 1878 "forgot to update kStatusLines");
1879 1879
1880 for (int i = 0; i < kNumUnreadBodies; ++i) 1880 for (int i = 0; i < kNumUnreadBodies; ++i)
1881 EXPECT_EQ(kStatusLines[i], response_lines[i]); 1881 EXPECT_EQ(kStatusLines[i], response_lines[i]);
1882 1882
1883 TestCompletionCallback callback; 1883 TestCompletionCallback callback;
1884 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 1884 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
1885 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 1885 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
1886 EXPECT_THAT(callback.GetResult(rv), IsOk()); 1886 EXPECT_THAT(callback.GetResult(rv), IsOk());
1887 const HttpResponseInfo* response = trans.GetResponseInfo(); 1887 const HttpResponseInfo* response = trans.GetResponseInfo();
1888 ASSERT_TRUE(response); 1888 ASSERT_TRUE(response);
1889 ASSERT_TRUE(response->headers); 1889 ASSERT_TRUE(response->headers);
1890 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 1890 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
1891 std::string response_data; 1891 std::string response_data;
1892 rv = ReadTransaction(&trans, &response_data); 1892 rv = ReadTransaction(&trans, &response_data);
1893 EXPECT_THAT(rv, IsOk()); 1893 EXPECT_THAT(rv, IsOk());
1894 EXPECT_EQ("hello", response_data); 1894 EXPECT_EQ("hello", response_data);
1895 } 1895 }
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
1929 data_writes2, arraysize(data_writes2)); 1929 data_writes2, arraysize(data_writes2));
1930 session_deps_.socket_factory->AddSocketDataProvider(&data2); 1930 session_deps_.socket_factory->AddSocketDataProvider(&data2);
1931 1931
1932 TestCompletionCallback callback; 1932 TestCompletionCallback callback;
1933 HttpRequestInfo request1; 1933 HttpRequestInfo request1;
1934 request1.method = "HEAD"; 1934 request1.method = "HEAD";
1935 request1.url = GURL("http://www.borked.com/"); 1935 request1.url = GURL("http://www.borked.com/");
1936 1936
1937 std::unique_ptr<HttpNetworkTransaction> trans1( 1937 std::unique_ptr<HttpNetworkTransaction> trans1(
1938 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 1938 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
1939 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); 1939 int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
1940 EXPECT_THAT(callback.GetResult(rv), IsOk()); 1940 EXPECT_THAT(callback.GetResult(rv), IsOk());
1941 1941
1942 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); 1942 const HttpResponseInfo* response1 = trans1->GetResponseInfo();
1943 ASSERT_TRUE(response1); 1943 ASSERT_TRUE(response1);
1944 ASSERT_TRUE(response1->headers); 1944 ASSERT_TRUE(response1->headers);
1945 EXPECT_EQ(200, response1->headers->response_code()); 1945 EXPECT_EQ(200, response1->headers->response_code());
1946 EXPECT_TRUE(response1->headers->IsKeepAlive()); 1946 EXPECT_TRUE(response1->headers->IsKeepAlive());
1947 1947
1948 std::string response_data1; 1948 std::string response_data1;
1949 EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk()); 1949 EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk());
1950 EXPECT_EQ("", response_data1); 1950 EXPECT_EQ("", response_data1);
1951 // Deleting the transaction attempts to release the socket back into the 1951 // Deleting the transaction attempts to release the socket back into the
1952 // socket pool. 1952 // socket pool.
1953 trans1.reset(); 1953 trans1.reset();
1954 1954
1955 HttpRequestInfo request2; 1955 HttpRequestInfo request2;
1956 request2.method = "GET"; 1956 request2.method = "GET";
1957 request2.url = GURL("http://www.borked.com/foo"); 1957 request2.url = GURL("http://www.borked.com/foo");
1958 1958
1959 std::unique_ptr<HttpNetworkTransaction> trans2( 1959 std::unique_ptr<HttpNetworkTransaction> trans2(
1960 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 1960 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
1961 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); 1961 rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
1962 EXPECT_THAT(callback.GetResult(rv), IsOk()); 1962 EXPECT_THAT(callback.GetResult(rv), IsOk());
1963 1963
1964 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); 1964 const HttpResponseInfo* response2 = trans2->GetResponseInfo();
1965 ASSERT_TRUE(response2); 1965 ASSERT_TRUE(response2);
1966 ASSERT_TRUE(response2->headers); 1966 ASSERT_TRUE(response2->headers);
1967 EXPECT_EQ(200, response2->headers->response_code()); 1967 EXPECT_EQ(200, response2->headers->response_code());
1968 1968
1969 std::string response_data2; 1969 std::string response_data2;
1970 EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk()); 1970 EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk());
1971 EXPECT_EQ("foo", response_data2); 1971 EXPECT_EQ("foo", response_data2);
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
2005 data_writes2, arraysize(data_writes2)); 2005 data_writes2, arraysize(data_writes2));
2006 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2006 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2007 2007
2008 TestCompletionCallback callback; 2008 TestCompletionCallback callback;
2009 HttpRequestInfo request1; 2009 HttpRequestInfo request1;
2010 request1.method = "GET"; 2010 request1.method = "GET";
2011 request1.url = GURL("http://www.borked.com/"); 2011 request1.url = GURL("http://www.borked.com/");
2012 2012
2013 std::unique_ptr<HttpNetworkTransaction> trans1( 2013 std::unique_ptr<HttpNetworkTransaction> trans1(
2014 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 2014 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
2015 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); 2015 int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
2016 EXPECT_THAT(callback.GetResult(rv), IsOk()); 2016 EXPECT_THAT(callback.GetResult(rv), IsOk());
2017 2017
2018 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); 2018 const HttpResponseInfo* response1 = trans1->GetResponseInfo();
2019 ASSERT_TRUE(response1); 2019 ASSERT_TRUE(response1);
2020 ASSERT_TRUE(response1->headers); 2020 ASSERT_TRUE(response1->headers);
2021 EXPECT_EQ(200, response1->headers->response_code()); 2021 EXPECT_EQ(200, response1->headers->response_code());
2022 EXPECT_TRUE(response1->headers->IsKeepAlive()); 2022 EXPECT_TRUE(response1->headers->IsKeepAlive());
2023 2023
2024 std::string response_data1; 2024 std::string response_data1;
2025 EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk()); 2025 EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk());
2026 EXPECT_EQ("This server is borked.", response_data1); 2026 EXPECT_EQ("This server is borked.", response_data1);
2027 // Deleting the transaction attempts to release the socket back into the 2027 // Deleting the transaction attempts to release the socket back into the
2028 // socket pool. 2028 // socket pool.
2029 trans1.reset(); 2029 trans1.reset();
2030 2030
2031 HttpRequestInfo request2; 2031 HttpRequestInfo request2;
2032 request2.method = "GET"; 2032 request2.method = "GET";
2033 request2.url = GURL("http://www.borked.com/foo"); 2033 request2.url = GURL("http://www.borked.com/foo");
2034 2034
2035 std::unique_ptr<HttpNetworkTransaction> trans2( 2035 std::unique_ptr<HttpNetworkTransaction> trans2(
2036 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 2036 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
2037 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); 2037 rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
2038 EXPECT_THAT(callback.GetResult(rv), IsOk()); 2038 EXPECT_THAT(callback.GetResult(rv), IsOk());
2039 2039
2040 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); 2040 const HttpResponseInfo* response2 = trans2->GetResponseInfo();
2041 ASSERT_TRUE(response2); 2041 ASSERT_TRUE(response2);
2042 ASSERT_TRUE(response2->headers); 2042 ASSERT_TRUE(response2->headers);
2043 EXPECT_EQ(200, response2->headers->response_code()); 2043 EXPECT_EQ(200, response2->headers->response_code());
2044 2044
2045 std::string response_data2; 2045 std::string response_data2;
2046 EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk()); 2046 EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk());
2047 EXPECT_EQ("foo", response_data2); 2047 EXPECT_EQ("foo", response_data2);
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
2081 data_writes2, arraysize(data_writes2)); 2081 data_writes2, arraysize(data_writes2));
2082 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2082 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2083 2083
2084 TestCompletionCallback callback; 2084 TestCompletionCallback callback;
2085 HttpRequestInfo request1; 2085 HttpRequestInfo request1;
2086 request1.method = "GET"; 2086 request1.method = "GET";
2087 request1.url = GURL("http://www.borked.com/"); 2087 request1.url = GURL("http://www.borked.com/");
2088 2088
2089 std::unique_ptr<HttpNetworkTransaction> trans1( 2089 std::unique_ptr<HttpNetworkTransaction> trans1(
2090 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 2090 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
2091 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); 2091 int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
2092 EXPECT_THAT(callback.GetResult(rv), IsOk()); 2092 EXPECT_THAT(callback.GetResult(rv), IsOk());
2093 2093
2094 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); 2094 const HttpResponseInfo* response1 = trans1->GetResponseInfo();
2095 ASSERT_TRUE(response1); 2095 ASSERT_TRUE(response1);
2096 ASSERT_TRUE(response1->headers); 2096 ASSERT_TRUE(response1->headers);
2097 EXPECT_EQ(200, response1->headers->response_code()); 2097 EXPECT_EQ(200, response1->headers->response_code());
2098 EXPECT_TRUE(response1->headers->IsKeepAlive()); 2098 EXPECT_TRUE(response1->headers->IsKeepAlive());
2099 2099
2100 std::string response_data1; 2100 std::string response_data1;
2101 EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk()); 2101 EXPECT_THAT(ReadTransaction(trans1.get(), &response_data1), IsOk());
2102 EXPECT_EQ("This server is borked.", response_data1); 2102 EXPECT_EQ("This server is borked.", response_data1);
2103 // Deleting the transaction attempts to release the socket back into the 2103 // Deleting the transaction attempts to release the socket back into the
2104 // socket pool. 2104 // socket pool.
2105 trans1.reset(); 2105 trans1.reset();
2106 2106
2107 HttpRequestInfo request2; 2107 HttpRequestInfo request2;
2108 request2.method = "GET"; 2108 request2.method = "GET";
2109 request2.url = GURL("http://www.borked.com/foo"); 2109 request2.url = GURL("http://www.borked.com/foo");
2110 2110
2111 std::unique_ptr<HttpNetworkTransaction> trans2( 2111 std::unique_ptr<HttpNetworkTransaction> trans2(
2112 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 2112 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
2113 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); 2113 rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
2114 EXPECT_THAT(callback.GetResult(rv), IsOk()); 2114 EXPECT_THAT(callback.GetResult(rv), IsOk());
2115 2115
2116 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); 2116 const HttpResponseInfo* response2 = trans2->GetResponseInfo();
2117 ASSERT_TRUE(response2); 2117 ASSERT_TRUE(response2);
2118 ASSERT_TRUE(response2->headers); 2118 ASSERT_TRUE(response2->headers);
2119 EXPECT_EQ(200, response2->headers->response_code()); 2119 EXPECT_EQ(200, response2->headers->response_code());
2120 2120
2121 std::string response_data2; 2121 std::string response_data2;
2122 EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk()); 2122 EXPECT_THAT(ReadTransaction(trans2.get(), &response_data2), IsOk());
2123 EXPECT_EQ("foo", response_data2); 2123 EXPECT_EQ("foo", response_data2);
(...skipping 22 matching lines...) Expand all
2146 data_writes1, arraysize(data_writes1)); 2146 data_writes1, arraysize(data_writes1));
2147 session_deps_.socket_factory->AddSocketDataProvider(&data1); 2147 session_deps_.socket_factory->AddSocketDataProvider(&data1);
2148 2148
2149 TestCompletionCallback callback; 2149 TestCompletionCallback callback;
2150 HttpRequestInfo request1; 2150 HttpRequestInfo request1;
2151 request1.method = "GET"; 2151 request1.method = "GET";
2152 request1.url = GURL("http://www.borked.com/"); 2152 request1.url = GURL("http://www.borked.com/");
2153 2153
2154 std::unique_ptr<HttpNetworkTransaction> trans1( 2154 std::unique_ptr<HttpNetworkTransaction> trans1(
2155 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 2155 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
2156 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); 2156 int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
2157 EXPECT_THAT(callback.GetResult(rv), IsOk()); 2157 EXPECT_THAT(callback.GetResult(rv), IsOk());
2158 2158
2159 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); 2159 const HttpResponseInfo* response1 = trans1->GetResponseInfo();
2160 ASSERT_TRUE(response1); 2160 ASSERT_TRUE(response1);
2161 ASSERT_TRUE(response1->headers); 2161 ASSERT_TRUE(response1->headers);
2162 EXPECT_EQ(200, response1->headers->response_code()); 2162 EXPECT_EQ(200, response1->headers->response_code());
2163 EXPECT_TRUE(response1->headers->IsKeepAlive()); 2163 EXPECT_TRUE(response1->headers->IsKeepAlive());
2164 2164
2165 // Deleting the transaction creates an HttpResponseBodyDrainer to read the 2165 // Deleting the transaction creates an HttpResponseBodyDrainer to read the
2166 // response body. 2166 // response body.
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
2227 2227
2228 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 2228 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2229 data_writes1, arraysize(data_writes1)); 2229 data_writes1, arraysize(data_writes1));
2230 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 2230 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
2231 data_writes2, arraysize(data_writes2)); 2231 data_writes2, arraysize(data_writes2));
2232 session_deps_.socket_factory->AddSocketDataProvider(&data1); 2232 session_deps_.socket_factory->AddSocketDataProvider(&data1);
2233 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2233 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2234 2234
2235 TestCompletionCallback callback1; 2235 TestCompletionCallback callback1;
2236 2236
2237 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 2237 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
2238 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2238 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2239 2239
2240 rv = callback1.WaitForResult(); 2240 rv = callback1.WaitForResult();
2241 EXPECT_THAT(rv, IsOk()); 2241 EXPECT_THAT(rv, IsOk());
2242 2242
2243 LoadTimingInfo load_timing_info1; 2243 LoadTimingInfo load_timing_info1;
2244 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info1)); 2244 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info1));
2245 TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES); 2245 TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES);
2246 2246
2247 int64_t writes_size1 = CountWriteBytes(data_writes1, arraysize(data_writes1)); 2247 int64_t writes_size1 = CountWriteBytes(data_writes1, arraysize(data_writes1));
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after
2337 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 2337 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2338 data_writes1, arraysize(data_writes1)); 2338 data_writes1, arraysize(data_writes1));
2339 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 2339 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
2340 data_writes2, arraysize(data_writes2)); 2340 data_writes2, arraysize(data_writes2));
2341 session_deps_.socket_factory->AddSocketDataProvider(&data1); 2341 session_deps_.socket_factory->AddSocketDataProvider(&data1);
2342 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2342 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2343 2343
2344 TestCompletionCallback callback1; 2344 TestCompletionCallback callback1;
2345 2345
2346 EXPECT_EQ(OK, callback1.GetResult(trans.Start(&request, callback1.callback(), 2346 EXPECT_EQ(OK, callback1.GetResult(trans.Start(&request, callback1.callback(),
2347 BoundNetLog()))); 2347 NetLogWithSource())));
2348 2348
2349 LoadTimingInfo load_timing_info1; 2349 LoadTimingInfo load_timing_info1;
2350 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info1)); 2350 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info1));
2351 TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES); 2351 TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES);
2352 2352
2353 int64_t writes_size1 = CountWriteBytes(data_writes1, arraysize(data_writes1)); 2353 int64_t writes_size1 = CountWriteBytes(data_writes1, arraysize(data_writes1));
2354 EXPECT_EQ(writes_size1, trans.GetTotalSentBytes()); 2354 EXPECT_EQ(writes_size1, trans.GetTotalSentBytes());
2355 int64_t reads_size1 = CountReadBytes(data_reads1, arraysize(data_reads1)); 2355 int64_t reads_size1 = CountReadBytes(data_reads1, arraysize(data_reads1));
2356 EXPECT_EQ(reads_size1, trans.GetTotalReceivedBytes()); 2356 EXPECT_EQ(reads_size1, trans.GetTotalReceivedBytes());
2357 2357
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
2419 // Large content-length -- won't matter, as connection will be reset. 2419 // Large content-length -- won't matter, as connection will be reset.
2420 MockRead("Content-Length: 10000\r\n\r\n"), 2420 MockRead("Content-Length: 10000\r\n\r\n"),
2421 MockRead(SYNCHRONOUS, ERR_FAILED), 2421 MockRead(SYNCHRONOUS, ERR_FAILED),
2422 }; 2422 };
2423 2423
2424 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 2424 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
2425 data_writes, arraysize(data_writes)); 2425 data_writes, arraysize(data_writes));
2426 session_deps_.socket_factory->AddSocketDataProvider(&data); 2426 session_deps_.socket_factory->AddSocketDataProvider(&data);
2427 TestCompletionCallback callback; 2427 TestCompletionCallback callback;
2428 2428
2429 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 2429 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
2430 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2430 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2431 2431
2432 rv = callback.WaitForResult(); 2432 rv = callback.WaitForResult();
2433 EXPECT_EQ(0, rv); 2433 EXPECT_EQ(0, rv);
2434 2434
2435 int64_t writes_size = CountWriteBytes(data_writes, arraysize(data_writes)); 2435 int64_t writes_size = CountWriteBytes(data_writes, arraysize(data_writes));
2436 EXPECT_EQ(writes_size, trans.GetTotalSentBytes()); 2436 EXPECT_EQ(writes_size, trans.GetTotalSentBytes());
2437 int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads)); 2437 int64_t reads_size = CountReadBytes(data_reads, arraysize(data_reads));
2438 EXPECT_EQ(reads_size, trans.GetTotalReceivedBytes()); 2438 EXPECT_EQ(reads_size, trans.GetTotalReceivedBytes());
2439 2439
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
2488 }; 2488 };
2489 2489
2490 SequencedSocketData data(data_reads, arraysize(data_reads), data_writes, 2490 SequencedSocketData data(data_reads, arraysize(data_reads), data_writes,
2491 arraysize(data_writes)); 2491 arraysize(data_writes));
2492 data.set_busy_before_sync_reads(true); 2492 data.set_busy_before_sync_reads(true);
2493 session_deps_.socket_factory->AddSocketDataProvider(&data); 2493 session_deps_.socket_factory->AddSocketDataProvider(&data);
2494 2494
2495 TestCompletionCallback callback1; 2495 TestCompletionCallback callback1;
2496 2496
2497 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 2497 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
2498 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 2498 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
2499 ASSERT_THAT(callback1.GetResult(rv), IsOk()); 2499 ASSERT_THAT(callback1.GetResult(rv), IsOk());
2500 2500
2501 LoadTimingInfo load_timing_info1; 2501 LoadTimingInfo load_timing_info1;
2502 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info1)); 2502 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info1));
2503 TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES); 2503 TestLoadTimingNotReused(load_timing_info1, CONNECT_TIMING_HAS_DNS_TIMES);
2504 2504
2505 const HttpResponseInfo* response = trans.GetResponseInfo(); 2505 const HttpResponseInfo* response = trans.GetResponseInfo();
2506 ASSERT_TRUE(response); 2506 ASSERT_TRUE(response);
2507 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 2507 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
2508 2508
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
2579 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 2579 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2580 data_writes1, arraysize(data_writes1)); 2580 data_writes1, arraysize(data_writes1));
2581 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 2581 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
2582 NULL, 0); 2582 NULL, 0);
2583 session_deps_.socket_factory->AddSocketDataProvider(&data1); 2583 session_deps_.socket_factory->AddSocketDataProvider(&data1);
2584 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2584 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2585 2585
2586 TestCompletionCallback callback1; 2586 TestCompletionCallback callback1;
2587 2587
2588 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 2588 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
2589 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 2589 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
2590 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2590 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2591 2591
2592 rv = callback1.WaitForResult(); 2592 rv = callback1.WaitForResult();
2593 EXPECT_THAT(rv, IsOk()); 2593 EXPECT_THAT(rv, IsOk());
2594 2594
2595 const HttpResponseInfo* response = trans.GetResponseInfo(); 2595 const HttpResponseInfo* response = trans.GetResponseInfo();
2596 ASSERT_TRUE(response); 2596 ASSERT_TRUE(response);
2597 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 2597 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
2598 2598
2599 TestCompletionCallback callback2; 2599 TestCompletionCallback callback2;
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
2661 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 2661 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2662 data_writes1, arraysize(data_writes1)); 2662 data_writes1, arraysize(data_writes1));
2663 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 2663 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
2664 NULL, 0); 2664 NULL, 0);
2665 session_deps_.socket_factory->AddSocketDataProvider(&data1); 2665 session_deps_.socket_factory->AddSocketDataProvider(&data1);
2666 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2666 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2667 2667
2668 TestCompletionCallback callback1; 2668 TestCompletionCallback callback1;
2669 2669
2670 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 2670 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
2671 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 2671 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
2672 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2672 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2673 2673
2674 rv = callback1.WaitForResult(); 2674 rv = callback1.WaitForResult();
2675 EXPECT_THAT(rv, IsOk()); 2675 EXPECT_THAT(rv, IsOk());
2676 2676
2677 const HttpResponseInfo* response = trans.GetResponseInfo(); 2677 const HttpResponseInfo* response = trans.GetResponseInfo();
2678 ASSERT_TRUE(response); 2678 ASSERT_TRUE(response);
2679 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 2679 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
2680 2680
2681 TestCompletionCallback callback2; 2681 TestCompletionCallback callback2;
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after
2748 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 2748 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
2749 data_writes1, arraysize(data_writes1)); 2749 data_writes1, arraysize(data_writes1));
2750 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 2750 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
2751 data_writes2, arraysize(data_writes2)); 2751 data_writes2, arraysize(data_writes2));
2752 session_deps_.socket_factory->AddSocketDataProvider(&data1); 2752 session_deps_.socket_factory->AddSocketDataProvider(&data1);
2753 session_deps_.socket_factory->AddSocketDataProvider(&data2); 2753 session_deps_.socket_factory->AddSocketDataProvider(&data2);
2754 2754
2755 TestCompletionCallback callback1; 2755 TestCompletionCallback callback1;
2756 2756
2757 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 2757 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
2758 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 2758 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
2759 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2759 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2760 2760
2761 rv = callback1.WaitForResult(); 2761 rv = callback1.WaitForResult();
2762 EXPECT_THAT(rv, IsOk()); 2762 EXPECT_THAT(rv, IsOk());
2763 2763
2764 const HttpResponseInfo* response = trans.GetResponseInfo(); 2764 const HttpResponseInfo* response = trans.GetResponseInfo();
2765 ASSERT_TRUE(response); 2765 ASSERT_TRUE(response);
2766 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 2766 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
2767 2767
2768 TestCompletionCallback callback2; 2768 TestCompletionCallback callback2;
(...skipping 664 matching lines...) Expand 10 before | Expand all | Expand 10 after
3433 data_writes1, arraysize(data_writes1)); 3433 data_writes1, arraysize(data_writes1));
3434 session_deps_.socket_factory->AddSocketDataProvider(&data1); 3434 session_deps_.socket_factory->AddSocketDataProvider(&data1);
3435 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 3435 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
3436 data_writes2, arraysize(data_writes2)); 3436 data_writes2, arraysize(data_writes2));
3437 session_deps_.socket_factory->AddSocketDataProvider(&data2); 3437 session_deps_.socket_factory->AddSocketDataProvider(&data2);
3438 SSLSocketDataProvider ssl(ASYNC, OK); 3438 SSLSocketDataProvider ssl(ASYNC, OK);
3439 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 3439 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
3440 3440
3441 TestCompletionCallback callback; 3441 TestCompletionCallback callback;
3442 3442
3443 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 3443 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
3444 EXPECT_THAT(callback.GetResult(rv), IsOk()); 3444 EXPECT_THAT(callback.GetResult(rv), IsOk());
3445 3445
3446 const HttpResponseInfo* response = trans.GetResponseInfo(); 3446 const HttpResponseInfo* response = trans.GetResponseInfo();
3447 ASSERT_TRUE(response); 3447 ASSERT_TRUE(response);
3448 ASSERT_TRUE(response->headers); 3448 ASSERT_TRUE(response->headers);
3449 EXPECT_TRUE(response->headers->IsKeepAlive()); 3449 EXPECT_TRUE(response->headers->IsKeepAlive());
3450 EXPECT_EQ(407, response->headers->response_code()); 3450 EXPECT_EQ(407, response->headers->response_code());
3451 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get())); 3451 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
3452 3452
3453 rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBar), callback.callback()); 3453 rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBar), callback.callback());
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
3493 MockRead("0123456789"), 3493 MockRead("0123456789"),
3494 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), 3494 MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
3495 }; 3495 };
3496 3496
3497 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 3497 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
3498 data_writes, arraysize(data_writes)); 3498 data_writes, arraysize(data_writes));
3499 session_deps_.socket_factory->AddSocketDataProvider(&data); 3499 session_deps_.socket_factory->AddSocketDataProvider(&data);
3500 3500
3501 TestCompletionCallback callback; 3501 TestCompletionCallback callback;
3502 3502
3503 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 3503 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
3504 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 3504 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
3505 3505
3506 rv = callback.WaitForResult(); 3506 rv = callback.WaitForResult();
3507 EXPECT_THAT(rv, IsOk()); 3507 EXPECT_THAT(rv, IsOk());
3508 3508
3509 const HttpResponseInfo* response = trans.GetResponseInfo(); 3509 const HttpResponseInfo* response = trans.GetResponseInfo();
3510 ASSERT_TRUE(response); 3510 ASSERT_TRUE(response);
3511 ASSERT_TRUE(response->headers); 3511 ASSERT_TRUE(response->headers);
3512 EXPECT_TRUE(response->headers->IsKeepAlive()); 3512 EXPECT_TRUE(response->headers->IsKeepAlive());
3513 EXPECT_EQ(407, response->headers->response_code()); 3513 EXPECT_EQ(407, response->headers->response_code());
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
3552 MockRead("Content-Length: 10\r\n\r\n"), 3552 MockRead("Content-Length: 10\r\n\r\n"),
3553 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), 3553 MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
3554 }; 3554 };
3555 3555
3556 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 3556 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
3557 arraysize(data_writes)); 3557 arraysize(data_writes));
3558 session_deps_.socket_factory->AddSocketDataProvider(&data); 3558 session_deps_.socket_factory->AddSocketDataProvider(&data);
3559 3559
3560 TestCompletionCallback callback; 3560 TestCompletionCallback callback;
3561 3561
3562 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 3562 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
3563 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 3563 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
3564 3564
3565 rv = callback.WaitForResult(); 3565 rv = callback.WaitForResult();
3566 EXPECT_THAT(rv, IsOk()); 3566 EXPECT_THAT(rv, IsOk());
3567 3567
3568 const HttpResponseInfo* response = trans.GetResponseInfo(); 3568 const HttpResponseInfo* response = trans.GetResponseInfo();
3569 ASSERT_TRUE(response); 3569 ASSERT_TRUE(response);
3570 ASSERT_TRUE(response->headers); 3570 ASSERT_TRUE(response->headers);
3571 EXPECT_TRUE(response->headers->IsKeepAlive()); 3571 EXPECT_TRUE(response->headers->IsKeepAlive());
3572 EXPECT_EQ(407, response->headers->response_code()); 3572 EXPECT_EQ(407, response->headers->response_code());
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
3608 MockRead("Content-Length: 10000\r\n\r\n"), 3608 MockRead("Content-Length: 10000\r\n\r\n"),
3609 MockRead(SYNCHRONOUS, ERR_FAILED), 3609 MockRead(SYNCHRONOUS, ERR_FAILED),
3610 }; 3610 };
3611 3611
3612 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 3612 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
3613 data_writes1, arraysize(data_writes1)); 3613 data_writes1, arraysize(data_writes1));
3614 session_deps_.socket_factory->AddSocketDataProvider(&data1); 3614 session_deps_.socket_factory->AddSocketDataProvider(&data1);
3615 3615
3616 TestCompletionCallback callback; 3616 TestCompletionCallback callback;
3617 3617
3618 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 3618 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
3619 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 3619 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
3620 3620
3621 rv = callback.WaitForResult(); 3621 rv = callback.WaitForResult();
3622 EXPECT_THAT(rv, IsError(ERR_UNEXPECTED_PROXY_AUTH)); 3622 EXPECT_THAT(rv, IsError(ERR_UNEXPECTED_PROXY_AUTH));
3623 } 3623 }
3624 3624
3625 // Tests when an HTTPS server (non-proxy) returns a 407 (proxy-authentication) 3625 // Tests when an HTTPS server (non-proxy) returns a 407 (proxy-authentication)
3626 // through a non-authenticating proxy. The request should fail with 3626 // through a non-authenticating proxy. The request should fail with
3627 // ERR_UNEXPECTED_PROXY_AUTH. 3627 // ERR_UNEXPECTED_PROXY_AUTH.
3628 // Note that it is impossible to detect if an HTTP server returns a 407 through 3628 // Note that it is impossible to detect if an HTTP server returns a 407 through
(...skipping 128 matching lines...) Expand 10 before | Expand all | Expand 10 after
3757 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 3757 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
3758 data_writes2, arraysize(data_writes2)); 3758 data_writes2, arraysize(data_writes2));
3759 session_deps_.socket_factory->AddSocketDataProvider(&data2); 3759 session_deps_.socket_factory->AddSocketDataProvider(&data2);
3760 SSLSocketDataProvider ssl(ASYNC, OK); 3760 SSLSocketDataProvider ssl(ASYNC, OK);
3761 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 3761 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
3762 3762
3763 std::unique_ptr<HttpNetworkTransaction> trans( 3763 std::unique_ptr<HttpNetworkTransaction> trans(
3764 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 3764 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
3765 3765
3766 TestCompletionCallback callback; 3766 TestCompletionCallback callback;
3767 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 3767 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
3768 EXPECT_THAT(callback.GetResult(rv), IsOk()); 3768 EXPECT_THAT(callback.GetResult(rv), IsOk());
3769 3769
3770 const HttpResponseInfo* response = trans->GetResponseInfo(); 3770 const HttpResponseInfo* response = trans->GetResponseInfo();
3771 ASSERT_TRUE(response); 3771 ASSERT_TRUE(response);
3772 ASSERT_TRUE(response->headers); 3772 ASSERT_TRUE(response->headers);
3773 EXPECT_FALSE(response->headers->IsKeepAlive()); 3773 EXPECT_FALSE(response->headers->IsKeepAlive());
3774 EXPECT_EQ(407, response->headers->response_code()); 3774 EXPECT_EQ(407, response->headers->response_code());
3775 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); 3775 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
3776 EXPECT_TRUE(trans->IsReadyToRestartForAuth()); 3776 EXPECT_TRUE(trans->IsReadyToRestartForAuth());
3777 EXPECT_FALSE(response->auth_challenge); 3777 EXPECT_FALSE(response->auth_challenge);
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after
3877 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 3877 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
3878 data_writes2, arraysize(data_writes2)); 3878 data_writes2, arraysize(data_writes2));
3879 session_deps_.socket_factory->AddSocketDataProvider(&data2); 3879 session_deps_.socket_factory->AddSocketDataProvider(&data2);
3880 SSLSocketDataProvider ssl(ASYNC, OK); 3880 SSLSocketDataProvider ssl(ASYNC, OK);
3881 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 3881 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
3882 3882
3883 std::unique_ptr<HttpNetworkTransaction> trans( 3883 std::unique_ptr<HttpNetworkTransaction> trans(
3884 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 3884 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
3885 3885
3886 TestCompletionCallback callback; 3886 TestCompletionCallback callback;
3887 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 3887 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
3888 EXPECT_THAT(callback.GetResult(rv), IsOk()); 3888 EXPECT_THAT(callback.GetResult(rv), IsOk());
3889 3889
3890 const HttpResponseInfo* response = trans->GetResponseInfo(); 3890 const HttpResponseInfo* response = trans->GetResponseInfo();
3891 ASSERT_TRUE(response); 3891 ASSERT_TRUE(response);
3892 ASSERT_TRUE(response->headers); 3892 ASSERT_TRUE(response->headers);
3893 EXPECT_TRUE(response->headers->IsKeepAlive()); 3893 EXPECT_TRUE(response->headers->IsKeepAlive());
3894 EXPECT_EQ(407, response->headers->response_code()); 3894 EXPECT_EQ(407, response->headers->response_code());
3895 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); 3895 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
3896 EXPECT_TRUE(trans->IsReadyToRestartForAuth()); 3896 EXPECT_TRUE(trans->IsReadyToRestartForAuth());
3897 EXPECT_FALSE(response->auth_challenge); 3897 EXPECT_FALSE(response->auth_challenge);
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after
3992 data_writes1, arraysize(data_writes1)); 3992 data_writes1, arraysize(data_writes1));
3993 session_deps_.socket_factory->AddSocketDataProvider(&data1); 3993 session_deps_.socket_factory->AddSocketDataProvider(&data1);
3994 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 3994 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
3995 data_writes2, arraysize(data_writes2)); 3995 data_writes2, arraysize(data_writes2));
3996 session_deps_.socket_factory->AddSocketDataProvider(&data2); 3996 session_deps_.socket_factory->AddSocketDataProvider(&data2);
3997 3997
3998 std::unique_ptr<HttpNetworkTransaction> trans( 3998 std::unique_ptr<HttpNetworkTransaction> trans(
3999 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 3999 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
4000 4000
4001 TestCompletionCallback callback; 4001 TestCompletionCallback callback;
4002 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 4002 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
4003 EXPECT_THAT(callback.GetResult(rv), IsOk()); 4003 EXPECT_THAT(callback.GetResult(rv), IsOk());
4004 4004
4005 const HttpResponseInfo* response = trans->GetResponseInfo(); 4005 const HttpResponseInfo* response = trans->GetResponseInfo();
4006 ASSERT_TRUE(response); 4006 ASSERT_TRUE(response);
4007 ASSERT_TRUE(response->headers); 4007 ASSERT_TRUE(response->headers);
4008 EXPECT_TRUE(response->headers->IsKeepAlive()); 4008 EXPECT_TRUE(response->headers->IsKeepAlive());
4009 EXPECT_EQ(407, response->headers->response_code()); 4009 EXPECT_EQ(407, response->headers->response_code());
4010 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); 4010 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
4011 EXPECT_TRUE(trans->IsReadyToRestartForAuth()); 4011 EXPECT_TRUE(trans->IsReadyToRestartForAuth());
4012 EXPECT_FALSE(response->auth_challenge); 4012 EXPECT_FALSE(response->auth_challenge);
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after
4091 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 4091 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
4092 data_writes2, arraysize(data_writes2)); 4092 data_writes2, arraysize(data_writes2));
4093 session_deps_.socket_factory->AddSocketDataProvider(&data2); 4093 session_deps_.socket_factory->AddSocketDataProvider(&data2);
4094 SSLSocketDataProvider ssl(ASYNC, OK); 4094 SSLSocketDataProvider ssl(ASYNC, OK);
4095 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 4095 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
4096 4096
4097 std::unique_ptr<HttpNetworkTransaction> trans( 4097 std::unique_ptr<HttpNetworkTransaction> trans(
4098 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 4098 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
4099 4099
4100 TestCompletionCallback callback; 4100 TestCompletionCallback callback;
4101 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 4101 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
4102 EXPECT_THAT(callback.GetResult(rv), IsOk()); 4102 EXPECT_THAT(callback.GetResult(rv), IsOk());
4103 4103
4104 const HttpResponseInfo* response = trans->GetResponseInfo(); 4104 const HttpResponseInfo* response = trans->GetResponseInfo();
4105 ASSERT_TRUE(response); 4105 ASSERT_TRUE(response);
4106 ASSERT_TRUE(response->headers); 4106 ASSERT_TRUE(response->headers);
4107 EXPECT_EQ(407, response->headers->response_code()); 4107 EXPECT_EQ(407, response->headers->response_code());
4108 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); 4108 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
4109 EXPECT_TRUE(trans->IsReadyToRestartForAuth()); 4109 EXPECT_TRUE(trans->IsReadyToRestartForAuth());
4110 EXPECT_FALSE(response->auth_challenge); 4110 EXPECT_FALSE(response->auth_challenge);
4111 4111
(...skipping 800 matching lines...) Expand 10 before | Expand all | Expand 10 after
4912 ssl.next_proto = kProtoHTTP2; 4912 ssl.next_proto = kProtoHTTP2;
4913 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 4913 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
4914 SSLSocketDataProvider ssl2(ASYNC, OK); 4914 SSLSocketDataProvider ssl2(ASYNC, OK);
4915 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); 4915 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
4916 SSLSocketDataProvider ssl3(ASYNC, OK); 4916 SSLSocketDataProvider ssl3(ASYNC, OK);
4917 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl3); 4917 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl3);
4918 4918
4919 TestCompletionCallback callback; 4919 TestCompletionCallback callback;
4920 4920
4921 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 4921 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
4922 int rv = trans.Start(&request1, callback.callback(), BoundNetLog()); 4922 int rv = trans.Start(&request1, callback.callback(), NetLogWithSource());
4923 EXPECT_THAT(callback.GetResult(rv), IsOk()); 4923 EXPECT_THAT(callback.GetResult(rv), IsOk());
4924 4924
4925 LoadTimingInfo load_timing_info; 4925 LoadTimingInfo load_timing_info;
4926 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 4926 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
4927 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES); 4927 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES);
4928 4928
4929 const HttpResponseInfo* response = trans.GetResponseInfo(); 4929 const HttpResponseInfo* response = trans.GetResponseInfo();
4930 ASSERT_TRUE(response); 4930 ASSERT_TRUE(response);
4931 ASSERT_TRUE(response->headers); 4931 ASSERT_TRUE(response->headers);
4932 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 4932 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
4933 4933
4934 std::string response_data; 4934 std::string response_data;
4935 scoped_refptr<IOBuffer> buf(new IOBuffer(256)); 4935 scoped_refptr<IOBuffer> buf(new IOBuffer(256));
4936 rv = trans.Read(buf.get(), 256, callback.callback()); 4936 rv = trans.Read(buf.get(), 256, callback.callback());
4937 EXPECT_EQ(1, callback.GetResult(rv)); 4937 EXPECT_EQ(1, callback.GetResult(rv));
4938 4938
4939 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 4939 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
4940 rv = trans2.Start(&request2, callback.callback(), BoundNetLog()); 4940 rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
4941 EXPECT_THAT(callback.GetResult(rv), IsOk()); 4941 EXPECT_THAT(callback.GetResult(rv), IsOk());
4942 4942
4943 LoadTimingInfo load_timing_info2; 4943 LoadTimingInfo load_timing_info2;
4944 EXPECT_TRUE(trans2.GetLoadTimingInfo(&load_timing_info2)); 4944 EXPECT_TRUE(trans2.GetLoadTimingInfo(&load_timing_info2));
4945 // Even though the SPDY connection is reused, a new tunnelled connection has 4945 // Even though the SPDY connection is reused, a new tunnelled connection has
4946 // to be created, so the socket's load timing looks like a fresh connection. 4946 // to be created, so the socket's load timing looks like a fresh connection.
4947 TestLoadTimingNotReused(load_timing_info2, CONNECT_TIMING_HAS_SSL_TIMES); 4947 TestLoadTimingNotReused(load_timing_info2, CONNECT_TIMING_HAS_SSL_TIMES);
4948 4948
4949 // The requests should have different IDs, since they each are using their own 4949 // The requests should have different IDs, since they each are using their own
4950 // separate stream. 4950 // separate stream.
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
5031 SSLSocketDataProvider ssl(ASYNC, OK); 5031 SSLSocketDataProvider ssl(ASYNC, OK);
5032 ssl.next_proto = kProtoHTTP2; 5032 ssl.next_proto = kProtoHTTP2;
5033 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 5033 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
5034 SSLSocketDataProvider ssl2(ASYNC, OK); 5034 SSLSocketDataProvider ssl2(ASYNC, OK);
5035 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); 5035 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
5036 5036
5037 TestCompletionCallback callback; 5037 TestCompletionCallback callback;
5038 5038
5039 std::unique_ptr<HttpNetworkTransaction> trans( 5039 std::unique_ptr<HttpNetworkTransaction> trans(
5040 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 5040 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
5041 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); 5041 int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
5042 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5042 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5043 5043
5044 rv = callback.WaitForResult(); 5044 rv = callback.WaitForResult();
5045 EXPECT_THAT(rv, IsOk()); 5045 EXPECT_THAT(rv, IsOk());
5046 5046
5047 LoadTimingInfo load_timing_info; 5047 LoadTimingInfo load_timing_info;
5048 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info)); 5048 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
5049 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES); 5049 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES);
5050 5050
5051 const HttpResponseInfo* response = trans->GetResponseInfo(); 5051 const HttpResponseInfo* response = trans->GetResponseInfo();
5052 ASSERT_TRUE(response); 5052 ASSERT_TRUE(response);
5053 ASSERT_TRUE(response->headers); 5053 ASSERT_TRUE(response->headers);
5054 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 5054 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
5055 5055
5056 std::string response_data; 5056 std::string response_data;
5057 scoped_refptr<IOBuffer> buf(new IOBuffer(256)); 5057 scoped_refptr<IOBuffer> buf(new IOBuffer(256));
5058 EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback())); 5058 EXPECT_EQ(1, trans->Read(buf.get(), 256, callback.callback()));
5059 trans.reset(); 5059 trans.reset();
5060 5060
5061 std::unique_ptr<HttpNetworkTransaction> trans2( 5061 std::unique_ptr<HttpNetworkTransaction> trans2(
5062 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 5062 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
5063 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); 5063 rv = trans2->Start(&request2, callback.callback(), NetLogWithSource());
5064 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5064 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5065 5065
5066 rv = callback.WaitForResult(); 5066 rv = callback.WaitForResult();
5067 EXPECT_THAT(rv, IsOk()); 5067 EXPECT_THAT(rv, IsOk());
5068 5068
5069 LoadTimingInfo load_timing_info2; 5069 LoadTimingInfo load_timing_info2;
5070 EXPECT_TRUE(trans2->GetLoadTimingInfo(&load_timing_info2)); 5070 EXPECT_TRUE(trans2->GetLoadTimingInfo(&load_timing_info2));
5071 TestLoadTimingReused(load_timing_info2); 5071 TestLoadTimingReused(load_timing_info2);
5072 5072
5073 // The requests should have the same ID. 5073 // The requests should have the same ID.
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
5131 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 5131 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
5132 5132
5133 SSLSocketDataProvider ssl(ASYNC, OK); 5133 SSLSocketDataProvider ssl(ASYNC, OK);
5134 ssl.next_proto = kProtoHTTP2; 5134 ssl.next_proto = kProtoHTTP2;
5135 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 5135 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
5136 5136
5137 TestCompletionCallback callback; 5137 TestCompletionCallback callback;
5138 5138
5139 std::unique_ptr<HttpNetworkTransaction> trans( 5139 std::unique_ptr<HttpNetworkTransaction> trans(
5140 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 5140 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
5141 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); 5141 int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
5142 EXPECT_THAT(callback.GetResult(rv), IsOk()); 5142 EXPECT_THAT(callback.GetResult(rv), IsOk());
5143 5143
5144 LoadTimingInfo load_timing_info; 5144 LoadTimingInfo load_timing_info;
5145 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info)); 5145 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
5146 TestLoadTimingNotReused(load_timing_info, 5146 TestLoadTimingNotReused(load_timing_info,
5147 CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY); 5147 CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
5148 5148
5149 const HttpResponseInfo* response = trans->GetResponseInfo(); 5149 const HttpResponseInfo* response = trans->GetResponseInfo();
5150 ASSERT_TRUE(response); 5150 ASSERT_TRUE(response);
5151 ASSERT_TRUE(response->headers); 5151 ASSERT_TRUE(response->headers);
5152 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 5152 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
5153 5153
5154 std::string response_data; 5154 std::string response_data;
5155 scoped_refptr<IOBuffer> buf(new IOBuffer(256)); 5155 scoped_refptr<IOBuffer> buf(new IOBuffer(256));
5156 rv = trans->Read(buf.get(), 256, callback.callback()); 5156 rv = trans->Read(buf.get(), 256, callback.callback());
5157 EXPECT_EQ(1, callback.GetResult(rv)); 5157 EXPECT_EQ(1, callback.GetResult(rv));
5158 // Delete the first request, so the second one can reuse the socket. 5158 // Delete the first request, so the second one can reuse the socket.
5159 trans.reset(); 5159 trans.reset();
5160 5160
5161 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 5161 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
5162 rv = trans2.Start(&request2, callback.callback(), BoundNetLog()); 5162 rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
5163 EXPECT_THAT(callback.GetResult(rv), IsOk()); 5163 EXPECT_THAT(callback.GetResult(rv), IsOk());
5164 5164
5165 LoadTimingInfo load_timing_info2; 5165 LoadTimingInfo load_timing_info2;
5166 EXPECT_TRUE(trans2.GetLoadTimingInfo(&load_timing_info2)); 5166 EXPECT_TRUE(trans2.GetLoadTimingInfo(&load_timing_info2));
5167 TestLoadTimingReused(load_timing_info2); 5167 TestLoadTimingReused(load_timing_info2);
5168 5168
5169 // The requests should have the same ID. 5169 // The requests should have the same ID.
5170 EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id); 5170 EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
5171 5171
5172 rv = trans2.Read(buf.get(), 256, callback.callback()); 5172 rv = trans2.Read(buf.get(), 256, callback.callback());
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after
5294 }; 5294 };
5295 5295
5296 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 5296 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
5297 data_writes, arraysize(data_writes)); 5297 data_writes, arraysize(data_writes));
5298 session_deps_.socket_factory->AddSocketDataProvider(&data); 5298 session_deps_.socket_factory->AddSocketDataProvider(&data);
5299 5299
5300 TestCompletionCallback callback; 5300 TestCompletionCallback callback;
5301 5301
5302 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 5302 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
5303 5303
5304 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 5304 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
5305 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5305 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5306 5306
5307 rv = callback.WaitForResult(); 5307 rv = callback.WaitForResult();
5308 EXPECT_EQ(expected_status, rv); 5308 EXPECT_EQ(expected_status, rv);
5309 } 5309 }
5310 5310
5311 void HttpNetworkTransactionTest::ConnectStatusHelper( 5311 void HttpNetworkTransactionTest::ConnectStatusHelper(
5312 const MockRead& status) { 5312 const MockRead& status) {
5313 ConnectStatusHelperWithExpectedStatus( 5313 ConnectStatusHelperWithExpectedStatus(
5314 status, ERR_TUNNEL_CONNECTION_FAILED); 5314 status, ERR_TUNNEL_CONNECTION_FAILED);
(...skipping 249 matching lines...) Expand 10 before | Expand all | Expand 10 after
5564 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 5564 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
5565 data_writes2, arraysize(data_writes2)); 5565 data_writes2, arraysize(data_writes2));
5566 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3), 5566 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
5567 data_writes3, arraysize(data_writes3)); 5567 data_writes3, arraysize(data_writes3));
5568 session_deps_.socket_factory->AddSocketDataProvider(&data1); 5568 session_deps_.socket_factory->AddSocketDataProvider(&data1);
5569 session_deps_.socket_factory->AddSocketDataProvider(&data2); 5569 session_deps_.socket_factory->AddSocketDataProvider(&data2);
5570 session_deps_.socket_factory->AddSocketDataProvider(&data3); 5570 session_deps_.socket_factory->AddSocketDataProvider(&data3);
5571 5571
5572 TestCompletionCallback callback1; 5572 TestCompletionCallback callback1;
5573 5573
5574 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 5574 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
5575 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5575 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5576 5576
5577 rv = callback1.WaitForResult(); 5577 rv = callback1.WaitForResult();
5578 EXPECT_THAT(rv, IsOk()); 5578 EXPECT_THAT(rv, IsOk());
5579 5579
5580 const HttpResponseInfo* response = trans.GetResponseInfo(); 5580 const HttpResponseInfo* response = trans.GetResponseInfo();
5581 ASSERT_TRUE(response); 5581 ASSERT_TRUE(response);
5582 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get())); 5582 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
5583 5583
5584 TestCompletionCallback callback2; 5584 TestCompletionCallback callback2;
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after
5698 data_writes1, arraysize(data_writes1)); 5698 data_writes1, arraysize(data_writes1));
5699 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 5699 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
5700 data_writes2, arraysize(data_writes2)); 5700 data_writes2, arraysize(data_writes2));
5701 session_deps_.socket_factory->AddSocketDataProvider(&data1); 5701 session_deps_.socket_factory->AddSocketDataProvider(&data1);
5702 session_deps_.socket_factory->AddSocketDataProvider(&data2); 5702 session_deps_.socket_factory->AddSocketDataProvider(&data2);
5703 5703
5704 TestCompletionCallback callback1; 5704 TestCompletionCallback callback1;
5705 5705
5706 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 5706 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
5707 5707
5708 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 5708 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
5709 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5709 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5710 5710
5711 rv = callback1.WaitForResult(); 5711 rv = callback1.WaitForResult();
5712 EXPECT_THAT(rv, IsOk()); 5712 EXPECT_THAT(rv, IsOk());
5713 5713
5714 EXPECT_FALSE(trans.IsReadyToRestartForAuth()); 5714 EXPECT_FALSE(trans.IsReadyToRestartForAuth());
5715 5715
5716 const HttpResponseInfo* response = trans.GetResponseInfo(); 5716 const HttpResponseInfo* response = trans.GetResponseInfo();
5717 ASSERT_TRUE(response); 5717 ASSERT_TRUE(response);
5718 EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get())); 5718 EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get()));
(...skipping 158 matching lines...) Expand 10 before | Expand all | Expand 10 after
5877 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3), 5877 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
5878 data_writes3, arraysize(data_writes3)); 5878 data_writes3, arraysize(data_writes3));
5879 session_deps_.socket_factory->AddSocketDataProvider(&data1); 5879 session_deps_.socket_factory->AddSocketDataProvider(&data1);
5880 session_deps_.socket_factory->AddSocketDataProvider(&data2); 5880 session_deps_.socket_factory->AddSocketDataProvider(&data2);
5881 session_deps_.socket_factory->AddSocketDataProvider(&data3); 5881 session_deps_.socket_factory->AddSocketDataProvider(&data3);
5882 5882
5883 TestCompletionCallback callback1; 5883 TestCompletionCallback callback1;
5884 5884
5885 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 5885 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
5886 5886
5887 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 5887 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
5888 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5888 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5889 5889
5890 rv = callback1.WaitForResult(); 5890 rv = callback1.WaitForResult();
5891 EXPECT_THAT(rv, IsOk()); 5891 EXPECT_THAT(rv, IsOk());
5892 5892
5893 EXPECT_FALSE(trans.IsReadyToRestartForAuth()); 5893 EXPECT_FALSE(trans.IsReadyToRestartForAuth());
5894 5894
5895 const HttpResponseInfo* response = trans.GetResponseInfo(); 5895 const HttpResponseInfo* response = trans.GetResponseInfo();
5896 ASSERT_TRUE(response); 5896 ASSERT_TRUE(response);
5897 EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get())); 5897 EXPECT_TRUE(CheckNTLMServerAuth(response->auth_challenge.get()));
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
5965 MockRead("HTTP/1.0 200 OK\r\n"), 5965 MockRead("HTTP/1.0 200 OK\r\n"),
5966 MockRead(ASYNC, large_headers_string.data(), large_headers_string.size()), 5966 MockRead(ASYNC, large_headers_string.data(), large_headers_string.size()),
5967 MockRead("\r\nBODY"), 5967 MockRead("\r\nBODY"),
5968 MockRead(SYNCHRONOUS, OK), 5968 MockRead(SYNCHRONOUS, OK),
5969 }; 5969 };
5970 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 5970 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
5971 session_deps_.socket_factory->AddSocketDataProvider(&data); 5971 session_deps_.socket_factory->AddSocketDataProvider(&data);
5972 5972
5973 TestCompletionCallback callback; 5973 TestCompletionCallback callback;
5974 5974
5975 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 5975 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
5976 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 5976 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
5977 5977
5978 rv = callback.WaitForResult(); 5978 rv = callback.WaitForResult();
5979 EXPECT_THAT(rv, IsError(ERR_RESPONSE_HEADERS_TOO_BIG)); 5979 EXPECT_THAT(rv, IsError(ERR_RESPONSE_HEADERS_TOO_BIG));
5980 } 5980 }
5981 5981
5982 // Make sure that we don't try to reuse a TCPClientSocket when failing to 5982 // Make sure that we don't try to reuse a TCPClientSocket when failing to
5983 // establish tunnel. 5983 // establish tunnel.
5984 // http://code.google.com/p/chromium/issues/detail?id=3772 5984 // http://code.google.com/p/chromium/issues/detail?id=3772
5985 TEST_F(HttpNetworkTransactionTest, DontRecycleTransportSocketForSSLTunnel) { 5985 TEST_F(HttpNetworkTransactionTest, DontRecycleTransportSocketForSSLTunnel) {
(...skipping 25 matching lines...) Expand all
6011 MockRead("Content-Length: 10\r\n\r\n"), 6011 MockRead("Content-Length: 10\r\n\r\n"),
6012 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), 6012 MockRead(SYNCHRONOUS, ERR_UNEXPECTED),
6013 }; 6013 };
6014 6014
6015 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 6015 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
6016 data_writes1, arraysize(data_writes1)); 6016 data_writes1, arraysize(data_writes1));
6017 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6017 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6018 6018
6019 TestCompletionCallback callback1; 6019 TestCompletionCallback callback1;
6020 6020
6021 int rv = trans->Start(&request, callback1.callback(), BoundNetLog()); 6021 int rv = trans->Start(&request, callback1.callback(), NetLogWithSource());
6022 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6022 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6023 6023
6024 rv = callback1.WaitForResult(); 6024 rv = callback1.WaitForResult();
6025 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED)); 6025 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED));
6026 6026
6027 // Empty the current queue. This is necessary because idle sockets are 6027 // Empty the current queue. This is necessary because idle sockets are
6028 // added to the connection pool asynchronously with a PostTask. 6028 // added to the connection pool asynchronously with a PostTask.
6029 base::RunLoop().RunUntilIdle(); 6029 base::RunLoop().RunUntilIdle();
6030 6030
6031 // We now check to make sure the TCPClientSocket was not added back to 6031 // We now check to make sure the TCPClientSocket was not added back to
(...skipping 24 matching lines...) Expand all
6056 MockRead(" world"), 6056 MockRead(" world"),
6057 MockRead("junk"), // Should not be read!! 6057 MockRead("junk"), // Should not be read!!
6058 MockRead(SYNCHRONOUS, OK), 6058 MockRead(SYNCHRONOUS, OK),
6059 }; 6059 };
6060 6060
6061 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 6061 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
6062 session_deps_.socket_factory->AddSocketDataProvider(&data); 6062 session_deps_.socket_factory->AddSocketDataProvider(&data);
6063 6063
6064 TestCompletionCallback callback; 6064 TestCompletionCallback callback;
6065 6065
6066 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 6066 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
6067 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6067 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6068 6068
6069 rv = callback.WaitForResult(); 6069 rv = callback.WaitForResult();
6070 EXPECT_THAT(rv, IsOk()); 6070 EXPECT_THAT(rv, IsOk());
6071 6071
6072 const HttpResponseInfo* response = trans.GetResponseInfo(); 6072 const HttpResponseInfo* response = trans.GetResponseInfo();
6073 ASSERT_TRUE(response); 6073 ASSERT_TRUE(response);
6074 6074
6075 EXPECT_TRUE(response->headers); 6075 EXPECT_TRUE(response->headers);
6076 std::string status_line = response->headers->GetStatusLine(); 6076 std::string status_line = response->headers->GetStatusLine();
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
6118 6118
6119 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 6119 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
6120 data_writes, arraysize(data_writes)); 6120 data_writes, arraysize(data_writes));
6121 session_deps_.socket_factory->AddSocketDataProvider(&data); 6121 session_deps_.socket_factory->AddSocketDataProvider(&data);
6122 6122
6123 TestCompletionCallback callback; 6123 TestCompletionCallback callback;
6124 6124
6125 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 6125 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
6126 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 6126 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
6127 6127
6128 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 6128 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
6129 6129
6130 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6130 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6131 EXPECT_THAT(callback.WaitForResult(), IsOk()); 6131 EXPECT_THAT(callback.WaitForResult(), IsOk());
6132 6132
6133 const HttpResponseInfo* response = trans.GetResponseInfo(); 6133 const HttpResponseInfo* response = trans.GetResponseInfo();
6134 ASSERT_TRUE(response); 6134 ASSERT_TRUE(response);
6135 ASSERT_TRUE(response->headers); 6135 ASSERT_TRUE(response->headers);
6136 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 6136 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
6137 6137
6138 EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get())); 6138 EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
6184 data_writes, arraysize(data_writes)); 6184 data_writes, arraysize(data_writes));
6185 session_deps_.socket_factory->AddSocketDataProvider(&data); 6185 session_deps_.socket_factory->AddSocketDataProvider(&data);
6186 session_deps_.socket_factory->AddSocketDataProvider(&data2); 6186 session_deps_.socket_factory->AddSocketDataProvider(&data2);
6187 6187
6188 TestCompletionCallback callback; 6188 TestCompletionCallback callback;
6189 6189
6190 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 6190 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
6191 std::unique_ptr<HttpNetworkTransaction> trans( 6191 std::unique_ptr<HttpNetworkTransaction> trans(
6192 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 6192 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
6193 6193
6194 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 6194 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
6195 6195
6196 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6196 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6197 EXPECT_THAT(callback.WaitForResult(), IsOk()); 6197 EXPECT_THAT(callback.WaitForResult(), IsOk());
6198 6198
6199 const HttpResponseInfo* response = trans->GetResponseInfo(); 6199 const HttpResponseInfo* response = trans->GetResponseInfo();
6200 ASSERT_TRUE(response); 6200 ASSERT_TRUE(response);
6201 ASSERT_TRUE(response->headers); 6201 ASSERT_TRUE(response->headers);
6202 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 6202 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
6203 6203
6204 EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get())); 6204 EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
6205 6205
6206 std::string response_data; 6206 std::string response_data;
6207 rv = ReadTransaction(trans.get(), &response_data); 6207 rv = ReadTransaction(trans.get(), &response_data);
6208 EXPECT_THAT(rv, IsOk()); 6208 EXPECT_THAT(rv, IsOk());
6209 EXPECT_EQ("hello world", response_data); 6209 EXPECT_EQ("hello world", response_data);
6210 6210
6211 // Empty the current queue. This is necessary because idle sockets are 6211 // Empty the current queue. This is necessary because idle sockets are
6212 // added to the connection pool asynchronously with a PostTask. 6212 // added to the connection pool asynchronously with a PostTask.
6213 base::RunLoop().RunUntilIdle(); 6213 base::RunLoop().RunUntilIdle();
6214 6214
6215 // We now check to make sure the socket was added back to the pool. 6215 // We now check to make sure the socket was added back to the pool.
6216 EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get())); 6216 EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
6217 6217
6218 // Now start the second transaction, which should reuse the previous socket. 6218 // Now start the second transaction, which should reuse the previous socket.
6219 6219
6220 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 6220 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
6221 6221
6222 rv = trans->Start(&request, callback.callback(), BoundNetLog()); 6222 rv = trans->Start(&request, callback.callback(), NetLogWithSource());
6223 6223
6224 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6224 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6225 EXPECT_THAT(callback.WaitForResult(), IsOk()); 6225 EXPECT_THAT(callback.WaitForResult(), IsOk());
6226 6226
6227 response = trans->GetResponseInfo(); 6227 response = trans->GetResponseInfo();
6228 ASSERT_TRUE(response); 6228 ASSERT_TRUE(response);
6229 ASSERT_TRUE(response->headers); 6229 ASSERT_TRUE(response->headers);
6230 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 6230 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
6231 6231
6232 EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get())); 6232 EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
(...skipping 29 matching lines...) Expand all
6262 MockRead("lo"), MockRead(" world"), 6262 MockRead("lo"), MockRead(" world"),
6263 MockRead("junk"), // Should not be read!! 6263 MockRead("junk"), // Should not be read!!
6264 MockRead(SYNCHRONOUS, OK), 6264 MockRead(SYNCHRONOUS, OK),
6265 }; 6265 };
6266 6266
6267 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 6267 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
6268 session_deps_.socket_factory->AddSocketDataProvider(&data); 6268 session_deps_.socket_factory->AddSocketDataProvider(&data);
6269 6269
6270 TestCompletionCallback callback; 6270 TestCompletionCallback callback;
6271 6271
6272 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 6272 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
6273 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6273 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6274 6274
6275 EXPECT_THAT(callback.GetResult(rv), IsOk()); 6275 EXPECT_THAT(callback.GetResult(rv), IsOk());
6276 6276
6277 const HttpResponseInfo* response = trans.GetResponseInfo(); 6277 const HttpResponseInfo* response = trans.GetResponseInfo();
6278 ASSERT_TRUE(response); 6278 ASSERT_TRUE(response);
6279 EXPECT_TRUE(response->headers); 6279 EXPECT_TRUE(response->headers);
6280 std::string status_line = response->headers->GetStatusLine(); 6280 std::string status_line = response->headers->GetStatusLine();
6281 EXPECT_EQ("HTTP/1.1 200 OK", status_line); 6281 EXPECT_EQ("HTTP/1.1 200 OK", status_line);
6282 6282
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
6333 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 6333 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
6334 arraysize(data_writes)); 6334 arraysize(data_writes));
6335 session_deps_.socket_factory->AddSocketDataProvider(&data); 6335 session_deps_.socket_factory->AddSocketDataProvider(&data);
6336 6336
6337 TestCompletionCallback callback; 6337 TestCompletionCallback callback;
6338 6338
6339 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 6339 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
6340 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 6340 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
6341 6341
6342 EXPECT_EQ(0, GetIdleSocketCountInSSLSocketPool(session.get())); 6342 EXPECT_EQ(0, GetIdleSocketCountInSSLSocketPool(session.get()));
6343 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 6343 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
6344 6344
6345 EXPECT_THAT(callback.GetResult(rv), IsOk()); 6345 EXPECT_THAT(callback.GetResult(rv), IsOk());
6346 6346
6347 const HttpResponseInfo* response = trans.GetResponseInfo(); 6347 const HttpResponseInfo* response = trans.GetResponseInfo();
6348 ASSERT_TRUE(response); 6348 ASSERT_TRUE(response);
6349 ASSERT_TRUE(response->headers); 6349 ASSERT_TRUE(response->headers);
6350 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 6350 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
6351 6351
6352 // Make memory critical notification and ensure the transaction still has been 6352 // Make memory critical notification and ensure the transaction still has been
6353 // operating right. 6353 // operating right.
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
6401 6401
6402 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 6402 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
6403 session_deps_.socket_factory->AddSocketDataProvider(&data); 6403 session_deps_.socket_factory->AddSocketDataProvider(&data);
6404 6404
6405 // Transaction must be created after the MockReads, so it's destroyed before 6405 // Transaction must be created after the MockReads, so it's destroyed before
6406 // them. 6406 // them.
6407 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 6407 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
6408 6408
6409 TestCompletionCallback callback; 6409 TestCompletionCallback callback;
6410 6410
6411 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 6411 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
6412 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6412 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6413 6413
6414 rv = callback.WaitForResult(); 6414 rv = callback.WaitForResult();
6415 EXPECT_THAT(rv, IsOk()); 6415 EXPECT_THAT(rv, IsOk());
6416 6416
6417 const HttpResponseInfo* response = trans.GetResponseInfo(); 6417 const HttpResponseInfo* response = trans.GetResponseInfo();
6418 ASSERT_TRUE(response); 6418 ASSERT_TRUE(response);
6419 6419
6420 EXPECT_TRUE(response->headers); 6420 EXPECT_TRUE(response->headers);
6421 std::string status_line = response->headers->GetStatusLine(); 6421 std::string status_line = response->headers->GetStatusLine();
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after
6499 6499
6500 const char* const kExpectedResponseData[] = { 6500 const char* const kExpectedResponseData[] = {
6501 "hello world", "welcome" 6501 "hello world", "welcome"
6502 }; 6502 };
6503 6503
6504 for (int i = 0; i < 2; ++i) { 6504 for (int i = 0; i < 2; ++i) {
6505 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 6505 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
6506 6506
6507 TestCompletionCallback callback; 6507 TestCompletionCallback callback;
6508 6508
6509 int rv = trans.Start(&request[i], callback.callback(), BoundNetLog()); 6509 int rv = trans.Start(&request[i], callback.callback(), NetLogWithSource());
6510 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6510 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6511 6511
6512 rv = callback.WaitForResult(); 6512 rv = callback.WaitForResult();
6513 EXPECT_THAT(rv, IsOk()); 6513 EXPECT_THAT(rv, IsOk());
6514 6514
6515 const HttpResponseInfo* response = trans.GetResponseInfo(); 6515 const HttpResponseInfo* response = trans.GetResponseInfo();
6516 ASSERT_TRUE(response); 6516 ASSERT_TRUE(response);
6517 6517
6518 EXPECT_TRUE(response->headers); 6518 EXPECT_TRUE(response->headers);
6519 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 6519 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
6572 }; 6572 };
6573 6573
6574 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 6574 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
6575 data_writes1, arraysize(data_writes1)); 6575 data_writes1, arraysize(data_writes1));
6576 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 6576 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
6577 data_writes2, arraysize(data_writes2)); 6577 data_writes2, arraysize(data_writes2));
6578 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6578 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6579 session_deps_.socket_factory->AddSocketDataProvider(&data2); 6579 session_deps_.socket_factory->AddSocketDataProvider(&data2);
6580 6580
6581 TestCompletionCallback callback1; 6581 TestCompletionCallback callback1;
6582 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 6582 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
6583 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6583 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6584 rv = callback1.WaitForResult(); 6584 rv = callback1.WaitForResult();
6585 EXPECT_THAT(rv, IsOk()); 6585 EXPECT_THAT(rv, IsOk());
6586 EXPECT_TRUE(trans.IsReadyToRestartForAuth()); 6586 EXPECT_TRUE(trans.IsReadyToRestartForAuth());
6587 6587
6588 TestCompletionCallback callback2; 6588 TestCompletionCallback callback2;
6589 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback()); 6589 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback());
6590 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6590 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6591 rv = callback2.WaitForResult(); 6591 rv = callback2.WaitForResult();
6592 EXPECT_THAT(rv, IsOk()); 6592 EXPECT_THAT(rv, IsOk());
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after
6671 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 6671 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
6672 data_writes2, arraysize(data_writes2)); 6672 data_writes2, arraysize(data_writes2));
6673 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3), 6673 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
6674 data_writes3, arraysize(data_writes3)); 6674 data_writes3, arraysize(data_writes3));
6675 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6675 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6676 session_deps_.socket_factory->AddSocketDataProvider(&data2); 6676 session_deps_.socket_factory->AddSocketDataProvider(&data2);
6677 session_deps_.socket_factory->AddSocketDataProvider(&data3); 6677 session_deps_.socket_factory->AddSocketDataProvider(&data3);
6678 6678
6679 TestCompletionCallback callback1; 6679 TestCompletionCallback callback1;
6680 6680
6681 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 6681 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
6682 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6682 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6683 6683
6684 rv = callback1.WaitForResult(); 6684 rv = callback1.WaitForResult();
6685 EXPECT_THAT(rv, IsOk()); 6685 EXPECT_THAT(rv, IsOk());
6686 6686
6687 EXPECT_TRUE(trans.IsReadyToRestartForAuth()); 6687 EXPECT_TRUE(trans.IsReadyToRestartForAuth());
6688 TestCompletionCallback callback2; 6688 TestCompletionCallback callback2;
6689 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback()); 6689 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback());
6690 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6690 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6691 rv = callback2.WaitForResult(); 6691 rv = callback2.WaitForResult();
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after
6760 }; 6760 };
6761 6761
6762 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 6762 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
6763 data_writes1, arraysize(data_writes1)); 6763 data_writes1, arraysize(data_writes1));
6764 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3), 6764 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
6765 data_writes3, arraysize(data_writes3)); 6765 data_writes3, arraysize(data_writes3));
6766 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6766 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6767 session_deps_.socket_factory->AddSocketDataProvider(&data3); 6767 session_deps_.socket_factory->AddSocketDataProvider(&data3);
6768 6768
6769 TestCompletionCallback callback1; 6769 TestCompletionCallback callback1;
6770 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 6770 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
6771 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6771 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6772 rv = callback1.WaitForResult(); 6772 rv = callback1.WaitForResult();
6773 EXPECT_THAT(rv, IsOk()); 6773 EXPECT_THAT(rv, IsOk());
6774 EXPECT_FALSE(trans.IsReadyToRestartForAuth()); 6774 EXPECT_FALSE(trans.IsReadyToRestartForAuth());
6775 6775
6776 const HttpResponseInfo* response = trans.GetResponseInfo(); 6776 const HttpResponseInfo* response = trans.GetResponseInfo();
6777 ASSERT_TRUE(response); 6777 ASSERT_TRUE(response);
6778 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 6778 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
6779 6779
6780 TestCompletionCallback callback3; 6780 TestCompletionCallback callback3;
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after
6840 6840
6841 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 6841 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
6842 data_writes1, arraysize(data_writes1)); 6842 data_writes1, arraysize(data_writes1));
6843 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 6843 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
6844 data_writes2, arraysize(data_writes2)); 6844 data_writes2, arraysize(data_writes2));
6845 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6845 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6846 session_deps_.socket_factory->AddSocketDataProvider(&data2); 6846 session_deps_.socket_factory->AddSocketDataProvider(&data2);
6847 6847
6848 TestCompletionCallback callback1; 6848 TestCompletionCallback callback1;
6849 6849
6850 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 6850 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
6851 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6851 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6852 6852
6853 rv = callback1.WaitForResult(); 6853 rv = callback1.WaitForResult();
6854 EXPECT_THAT(rv, IsOk()); 6854 EXPECT_THAT(rv, IsOk());
6855 6855
6856 const HttpResponseInfo* response = trans.GetResponseInfo(); 6856 const HttpResponseInfo* response = trans.GetResponseInfo();
6857 ASSERT_TRUE(response); 6857 ASSERT_TRUE(response);
6858 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 6858 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
6859 6859
6860 TestCompletionCallback callback2; 6860 TestCompletionCallback callback2;
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
6921 6921
6922 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 6922 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
6923 data_writes1, arraysize(data_writes1)); 6923 data_writes1, arraysize(data_writes1));
6924 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 6924 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
6925 data_writes2, arraysize(data_writes2)); 6925 data_writes2, arraysize(data_writes2));
6926 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6926 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6927 session_deps_.socket_factory->AddSocketDataProvider(&data2); 6927 session_deps_.socket_factory->AddSocketDataProvider(&data2);
6928 6928
6929 TestCompletionCallback callback1; 6929 TestCompletionCallback callback1;
6930 6930
6931 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 6931 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
6932 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6932 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6933 6933
6934 rv = callback1.WaitForResult(); 6934 rv = callback1.WaitForResult();
6935 EXPECT_THAT(rv, IsOk()); 6935 EXPECT_THAT(rv, IsOk());
6936 6936
6937 const HttpResponseInfo* response = trans.GetResponseInfo(); 6937 const HttpResponseInfo* response = trans.GetResponseInfo();
6938 ASSERT_TRUE(response); 6938 ASSERT_TRUE(response);
6939 ASSERT_TRUE(response->auth_challenge); 6939 ASSERT_TRUE(response->auth_challenge);
6940 EXPECT_FALSE(response->auth_challenge->is_proxy); 6940 EXPECT_FALSE(response->auth_challenge->is_proxy);
6941 EXPECT_EQ("http://www.example.org", 6941 EXPECT_EQ("http://www.example.org",
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
6986 MockRead("Content-Length: 100\r\n\r\n"), 6986 MockRead("Content-Length: 100\r\n\r\n"),
6987 MockRead(SYNCHRONOUS, OK), 6987 MockRead(SYNCHRONOUS, OK),
6988 }; 6988 };
6989 6989
6990 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 6990 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
6991 data_writes1, arraysize(data_writes1)); 6991 data_writes1, arraysize(data_writes1));
6992 session_deps_.socket_factory->AddSocketDataProvider(&data1); 6992 session_deps_.socket_factory->AddSocketDataProvider(&data1);
6993 6993
6994 TestCompletionCallback callback1; 6994 TestCompletionCallback callback1;
6995 6995
6996 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 6996 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
6997 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 6997 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
6998 6998
6999 rv = callback1.WaitForResult(); 6999 rv = callback1.WaitForResult();
7000 EXPECT_THAT(rv, IsOk()); 7000 EXPECT_THAT(rv, IsOk());
7001 7001
7002 const HttpResponseInfo* response = trans.GetResponseInfo(); 7002 const HttpResponseInfo* response = trans.GetResponseInfo();
7003 ASSERT_TRUE(response); 7003 ASSERT_TRUE(response);
7004 7004
7005 EXPECT_FALSE(response->auth_challenge); 7005 EXPECT_FALSE(response->auth_challenge);
7006 EXPECT_EQ(100, response->headers->GetContentLength()); 7006 EXPECT_EQ(100, response->headers->GetContentLength());
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
7050 7050
7051 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 7051 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
7052 data_writes1, arraysize(data_writes1)); 7052 data_writes1, arraysize(data_writes1));
7053 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 7053 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
7054 data_writes2, arraysize(data_writes2)); 7054 data_writes2, arraysize(data_writes2));
7055 session_deps_.socket_factory->AddSocketDataProvider(&data1); 7055 session_deps_.socket_factory->AddSocketDataProvider(&data1);
7056 session_deps_.socket_factory->AddSocketDataProvider(&data2); 7056 session_deps_.socket_factory->AddSocketDataProvider(&data2);
7057 7057
7058 TestCompletionCallback callback1; 7058 TestCompletionCallback callback1;
7059 7059
7060 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 7060 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
7061 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7061 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7062 7062
7063 rv = callback1.WaitForResult(); 7063 rv = callback1.WaitForResult();
7064 EXPECT_THAT(rv, IsOk()); 7064 EXPECT_THAT(rv, IsOk());
7065 7065
7066 EXPECT_TRUE(trans.IsReadyToRestartForAuth()); 7066 EXPECT_TRUE(trans.IsReadyToRestartForAuth());
7067 TestCompletionCallback callback2; 7067 TestCompletionCallback callback2;
7068 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback()); 7068 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback());
7069 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7069 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7070 rv = callback2.WaitForResult(); 7070 rv = callback2.WaitForResult();
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
7142 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 7142 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
7143 data_writes2, arraysize(data_writes2)); 7143 data_writes2, arraysize(data_writes2));
7144 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3), 7144 StaticSocketDataProvider data3(data_reads3, arraysize(data_reads3),
7145 data_writes3, arraysize(data_writes3)); 7145 data_writes3, arraysize(data_writes3));
7146 session_deps_.socket_factory->AddSocketDataProvider(&data1); 7146 session_deps_.socket_factory->AddSocketDataProvider(&data1);
7147 session_deps_.socket_factory->AddSocketDataProvider(&data2); 7147 session_deps_.socket_factory->AddSocketDataProvider(&data2);
7148 session_deps_.socket_factory->AddSocketDataProvider(&data3); 7148 session_deps_.socket_factory->AddSocketDataProvider(&data3);
7149 7149
7150 TestCompletionCallback callback1; 7150 TestCompletionCallback callback1;
7151 7151
7152 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 7152 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
7153 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7153 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7154 7154
7155 rv = callback1.WaitForResult(); 7155 rv = callback1.WaitForResult();
7156 EXPECT_THAT(rv, IsOk()); 7156 EXPECT_THAT(rv, IsOk());
7157 7157
7158 EXPECT_TRUE(trans.IsReadyToRestartForAuth()); 7158 EXPECT_TRUE(trans.IsReadyToRestartForAuth());
7159 TestCompletionCallback callback2; 7159 TestCompletionCallback callback2;
7160 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback()); 7160 rv = trans.RestartWithAuth(AuthCredentials(), callback2.callback());
7161 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7161 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7162 rv = callback2.WaitForResult(); 7162 rv = callback2.WaitForResult();
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after
7237 7237
7238 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 7238 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
7239 data_writes1, arraysize(data_writes1)); 7239 data_writes1, arraysize(data_writes1));
7240 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 7240 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
7241 data_writes2, arraysize(data_writes2)); 7241 data_writes2, arraysize(data_writes2));
7242 session_deps_.socket_factory->AddSocketDataProvider(&data1); 7242 session_deps_.socket_factory->AddSocketDataProvider(&data1);
7243 session_deps_.socket_factory->AddSocketDataProvider(&data2); 7243 session_deps_.socket_factory->AddSocketDataProvider(&data2);
7244 7244
7245 TestCompletionCallback callback1; 7245 TestCompletionCallback callback1;
7246 7246
7247 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 7247 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
7248 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7248 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7249 7249
7250 rv = callback1.WaitForResult(); 7250 rv = callback1.WaitForResult();
7251 EXPECT_THAT(rv, IsOk()); 7251 EXPECT_THAT(rv, IsOk());
7252 7252
7253 const HttpResponseInfo* response = trans.GetResponseInfo(); 7253 const HttpResponseInfo* response = trans.GetResponseInfo();
7254 ASSERT_TRUE(response); 7254 ASSERT_TRUE(response);
7255 EXPECT_TRUE(CheckDigestServerAuth(response->auth_challenge.get())); 7255 EXPECT_TRUE(CheckDigestServerAuth(response->auth_challenge.get()));
7256 7256
7257 TestCompletionCallback callback2; 7257 TestCompletionCallback callback2;
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
7300 MockRead("Content-Length: 100\r\n\r\n"), 7300 MockRead("Content-Length: 100\r\n\r\n"),
7301 MockRead(SYNCHRONOUS, OK), 7301 MockRead(SYNCHRONOUS, OK),
7302 }; 7302 };
7303 7303
7304 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), 7304 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1),
7305 data_writes1, arraysize(data_writes1)); 7305 data_writes1, arraysize(data_writes1));
7306 session_deps_.socket_factory->AddSocketDataProvider(&data1); 7306 session_deps_.socket_factory->AddSocketDataProvider(&data1);
7307 7307
7308 TestCompletionCallback callback1; 7308 TestCompletionCallback callback1;
7309 7309
7310 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 7310 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
7311 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7311 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7312 7312
7313 rv = callback1.WaitForResult(); 7313 rv = callback1.WaitForResult();
7314 EXPECT_THAT(rv, IsOk()); 7314 EXPECT_THAT(rv, IsOk());
7315 7315
7316 const HttpResponseInfo* response = trans.GetResponseInfo(); 7316 const HttpResponseInfo* response = trans.GetResponseInfo();
7317 ASSERT_TRUE(response); 7317 ASSERT_TRUE(response);
7318 EXPECT_FALSE(response->auth_challenge); 7318 EXPECT_FALSE(response->auth_challenge);
7319 } 7319 }
7320 } 7320 }
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
7391 SSLSocketDataProvider ssl_bad(ASYNC, ERR_CERT_AUTHORITY_INVALID); 7391 SSLSocketDataProvider ssl_bad(ASYNC, ERR_CERT_AUTHORITY_INVALID);
7392 SSLSocketDataProvider ssl(ASYNC, OK); 7392 SSLSocketDataProvider ssl(ASYNC, OK);
7393 7393
7394 session_deps_.socket_factory->AddSocketDataProvider(&ssl_bad_certificate); 7394 session_deps_.socket_factory->AddSocketDataProvider(&ssl_bad_certificate);
7395 session_deps_.socket_factory->AddSocketDataProvider(&data); 7395 session_deps_.socket_factory->AddSocketDataProvider(&data);
7396 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_bad); 7396 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_bad);
7397 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 7397 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
7398 7398
7399 TestCompletionCallback callback; 7399 TestCompletionCallback callback;
7400 7400
7401 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7401 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7402 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7402 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7403 7403
7404 rv = callback.WaitForResult(); 7404 rv = callback.WaitForResult();
7405 EXPECT_THAT(rv, IsError(ERR_CERT_AUTHORITY_INVALID)); 7405 EXPECT_THAT(rv, IsError(ERR_CERT_AUTHORITY_INVALID));
7406 7406
7407 rv = trans.RestartIgnoringLastError(callback.callback()); 7407 rv = trans.RestartIgnoringLastError(callback.callback());
7408 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7408 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7409 7409
7410 rv = callback.WaitForResult(); 7410 rv = callback.WaitForResult();
7411 EXPECT_THAT(rv, IsOk()); 7411 EXPECT_THAT(rv, IsOk());
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
7468 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 7468 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
7469 7469
7470 TestCompletionCallback callback; 7470 TestCompletionCallback callback;
7471 7471
7472 for (int i = 0; i < 2; i++) { 7472 for (int i = 0; i < 2; i++) {
7473 session_deps_.socket_factory->ResetNextMockIndexes(); 7473 session_deps_.socket_factory->ResetNextMockIndexes();
7474 7474
7475 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 7475 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
7476 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 7476 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
7477 7477
7478 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7478 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7479 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7479 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7480 7480
7481 rv = callback.WaitForResult(); 7481 rv = callback.WaitForResult();
7482 EXPECT_THAT(rv, IsError(ERR_CERT_AUTHORITY_INVALID)); 7482 EXPECT_THAT(rv, IsError(ERR_CERT_AUTHORITY_INVALID));
7483 7483
7484 rv = trans.RestartIgnoringLastError(callback.callback()); 7484 rv = trans.RestartIgnoringLastError(callback.callback());
7485 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7485 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7486 7486
7487 rv = callback.WaitForResult(); 7487 rv = callback.WaitForResult();
7488 EXPECT_THAT(rv, IsOk()); 7488 EXPECT_THAT(rv, IsOk());
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
7531 7531
7532 session_deps_.socket_factory->AddSocketDataProvider(&data); 7532 session_deps_.socket_factory->AddSocketDataProvider(&data);
7533 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); 7533 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
7534 session_deps_.socket_factory->AddSSLSocketDataProvider(&tunnel_ssl); 7534 session_deps_.socket_factory->AddSSLSocketDataProvider(&tunnel_ssl);
7535 7535
7536 TestCompletionCallback callback; 7536 TestCompletionCallback callback;
7537 7537
7538 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 7538 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
7539 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 7539 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
7540 7540
7541 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7541 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7542 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7542 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7543 7543
7544 rv = callback.WaitForResult(); 7544 rv = callback.WaitForResult();
7545 EXPECT_THAT(rv, IsOk()); 7545 EXPECT_THAT(rv, IsOk());
7546 const HttpResponseInfo* response = trans.GetResponseInfo(); 7546 const HttpResponseInfo* response = trans.GetResponseInfo();
7547 7547
7548 ASSERT_TRUE(response); 7548 ASSERT_TRUE(response);
7549 7549
7550 EXPECT_TRUE(response->headers->IsKeepAlive()); 7550 EXPECT_TRUE(response->headers->IsKeepAlive());
7551 EXPECT_EQ(200, response->headers->response_code()); 7551 EXPECT_EQ(200, response->headers->response_code());
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
7588 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy 7588 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy
7589 7589
7590 session_deps_.socket_factory->AddSocketDataProvider(&data); 7590 session_deps_.socket_factory->AddSocketDataProvider(&data);
7591 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); 7591 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
7592 7592
7593 TestCompletionCallback callback; 7593 TestCompletionCallback callback;
7594 7594
7595 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 7595 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
7596 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 7596 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
7597 7597
7598 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7598 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7599 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7599 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7600 7600
7601 rv = callback.WaitForResult(); 7601 rv = callback.WaitForResult();
7602 EXPECT_THAT(rv, IsOk()); 7602 EXPECT_THAT(rv, IsOk());
7603 const HttpResponseInfo* response = trans.GetResponseInfo(); 7603 const HttpResponseInfo* response = trans.GetResponseInfo();
7604 7604
7605 ASSERT_TRUE(response); 7605 ASSERT_TRUE(response);
7606 7606
7607 EXPECT_EQ(302, response->headers->response_code()); 7607 EXPECT_EQ(302, response->headers->response_code());
7608 std::string url; 7608 std::string url;
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after
7667 proxy_ssl.next_proto = kProtoHTTP2; 7667 proxy_ssl.next_proto = kProtoHTTP2;
7668 7668
7669 session_deps_.socket_factory->AddSocketDataProvider(&data); 7669 session_deps_.socket_factory->AddSocketDataProvider(&data);
7670 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); 7670 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
7671 7671
7672 TestCompletionCallback callback; 7672 TestCompletionCallback callback;
7673 7673
7674 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 7674 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
7675 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 7675 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
7676 7676
7677 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7677 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7678 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7678 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7679 7679
7680 rv = callback.WaitForResult(); 7680 rv = callback.WaitForResult();
7681 EXPECT_THAT(rv, IsOk()); 7681 EXPECT_THAT(rv, IsOk());
7682 const HttpResponseInfo* response = trans.GetResponseInfo(); 7682 const HttpResponseInfo* response = trans.GetResponseInfo();
7683 7683
7684 ASSERT_TRUE(response); 7684 ASSERT_TRUE(response);
7685 7685
7686 EXPECT_EQ(302, response->headers->response_code()); 7686 EXPECT_EQ(302, response->headers->response_code());
7687 std::string url; 7687 std::string url;
(...skipping 28 matching lines...) Expand all
7716 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy 7716 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy
7717 7717
7718 session_deps_.socket_factory->AddSocketDataProvider(&data); 7718 session_deps_.socket_factory->AddSocketDataProvider(&data);
7719 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); 7719 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
7720 7720
7721 TestCompletionCallback callback; 7721 TestCompletionCallback callback;
7722 7722
7723 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 7723 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
7724 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 7724 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
7725 7725
7726 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7726 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7727 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7727 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7728 7728
7729 rv = callback.WaitForResult(); 7729 rv = callback.WaitForResult();
7730 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED)); 7730 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED));
7731 7731
7732 // TODO(juliatuttle): Anything else to check here? 7732 // TODO(juliatuttle): Anything else to check here?
7733 } 7733 }
7734 7734
7735 // Test that a SPDY proxy's response to a CONNECT request is filtered. 7735 // Test that a SPDY proxy's response to a CONNECT request is filtered.
7736 TEST_F(HttpNetworkTransactionTest, ErrorResponseToHttpsConnectViaSpdyProxy) { 7736 TEST_F(HttpNetworkTransactionTest, ErrorResponseToHttpsConnectViaSpdyProxy) {
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
7768 proxy_ssl.next_proto = kProtoHTTP2; 7768 proxy_ssl.next_proto = kProtoHTTP2;
7769 7769
7770 session_deps_.socket_factory->AddSocketDataProvider(&data); 7770 session_deps_.socket_factory->AddSocketDataProvider(&data);
7771 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); 7771 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
7772 7772
7773 TestCompletionCallback callback; 7773 TestCompletionCallback callback;
7774 7774
7775 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 7775 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
7776 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 7776 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
7777 7777
7778 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 7778 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
7779 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 7779 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
7780 7780
7781 rv = callback.WaitForResult(); 7781 rv = callback.WaitForResult();
7782 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED)); 7782 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED));
7783 7783
7784 // TODO(juliatuttle): Anything else to check here? 7784 // TODO(juliatuttle): Anything else to check here?
7785 } 7785 }
7786 7786
7787 // Test the request-challenge-retry sequence for basic auth, through 7787 // Test the request-challenge-retry sequence for basic auth, through
7788 // a SPDY proxy over a single SPDY session. 7788 // a SPDY proxy over a single SPDY session.
(...skipping 466 matching lines...) Expand 10 before | Expand all | Expand 10 after
8255 // SSL to the proxy, then CONNECT request, then valid SSL certificate 8255 // SSL to the proxy, then CONNECT request, then valid SSL certificate
8256 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 8256 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
8257 session_deps_.socket_factory->AddSocketDataProvider(&data); 8257 session_deps_.socket_factory->AddSocketDataProvider(&data);
8258 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 8258 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
8259 8259
8260 TestCompletionCallback callback; 8260 TestCompletionCallback callback;
8261 8261
8262 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 8262 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
8263 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 8263 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
8264 8264
8265 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8265 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8266 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8266 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8267 8267
8268 rv = callback.WaitForResult(); 8268 rv = callback.WaitForResult();
8269 EXPECT_THAT(rv, IsError(ERR_CERT_AUTHORITY_INVALID)); 8269 EXPECT_THAT(rv, IsError(ERR_CERT_AUTHORITY_INVALID));
8270 8270
8271 rv = trans.RestartIgnoringLastError(callback.callback()); 8271 rv = trans.RestartIgnoringLastError(callback.callback());
8272 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8272 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8273 8273
8274 rv = callback.WaitForResult(); 8274 rv = callback.WaitForResult();
8275 EXPECT_THAT(rv, IsOk()); 8275 EXPECT_THAT(rv, IsOk());
(...skipping 29 matching lines...) Expand all
8305 MockRead("Content-Length: 100\r\n\r\n"), 8305 MockRead("Content-Length: 100\r\n\r\n"),
8306 MockRead(SYNCHRONOUS, OK), 8306 MockRead(SYNCHRONOUS, OK),
8307 }; 8307 };
8308 8308
8309 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8309 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8310 data_writes, arraysize(data_writes)); 8310 data_writes, arraysize(data_writes));
8311 session_deps_.socket_factory->AddSocketDataProvider(&data); 8311 session_deps_.socket_factory->AddSocketDataProvider(&data);
8312 8312
8313 TestCompletionCallback callback; 8313 TestCompletionCallback callback;
8314 8314
8315 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8315 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8316 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8316 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8317 8317
8318 rv = callback.WaitForResult(); 8318 rv = callback.WaitForResult();
8319 EXPECT_THAT(rv, IsOk()); 8319 EXPECT_THAT(rv, IsOk());
8320 } 8320 }
8321 8321
8322 TEST_F(HttpNetworkTransactionTest, BuildRequest_UserAgentOverTunnel) { 8322 TEST_F(HttpNetworkTransactionTest, BuildRequest_UserAgentOverTunnel) {
8323 HttpRequestInfo request; 8323 HttpRequestInfo request;
8324 request.method = "GET"; 8324 request.method = "GET";
8325 request.url = GURL("https://www.example.org/"); 8325 request.url = GURL("https://www.example.org/");
(...skipping 17 matching lines...) Expand all
8343 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), 8343 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
8344 MockRead("Proxy-Connection: close\r\n\r\n"), 8344 MockRead("Proxy-Connection: close\r\n\r\n"),
8345 }; 8345 };
8346 8346
8347 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8347 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8348 data_writes, arraysize(data_writes)); 8348 data_writes, arraysize(data_writes));
8349 session_deps_.socket_factory->AddSocketDataProvider(&data); 8349 session_deps_.socket_factory->AddSocketDataProvider(&data);
8350 8350
8351 TestCompletionCallback callback; 8351 TestCompletionCallback callback;
8352 8352
8353 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8353 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8354 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8354 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8355 8355
8356 rv = callback.WaitForResult(); 8356 rv = callback.WaitForResult();
8357 EXPECT_THAT(rv, IsOk()); 8357 EXPECT_THAT(rv, IsOk());
8358 } 8358 }
8359 8359
8360 TEST_F(HttpNetworkTransactionTest, BuildRequest_Referer) { 8360 TEST_F(HttpNetworkTransactionTest, BuildRequest_Referer) {
8361 HttpRequestInfo request; 8361 HttpRequestInfo request;
8362 request.method = "GET"; 8362 request.method = "GET";
8363 request.url = GURL("http://www.example.org/"); 8363 request.url = GURL("http://www.example.org/");
(...skipping 19 matching lines...) Expand all
8383 MockRead("Content-Length: 100\r\n\r\n"), 8383 MockRead("Content-Length: 100\r\n\r\n"),
8384 MockRead(SYNCHRONOUS, OK), 8384 MockRead(SYNCHRONOUS, OK),
8385 }; 8385 };
8386 8386
8387 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8387 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8388 data_writes, arraysize(data_writes)); 8388 data_writes, arraysize(data_writes));
8389 session_deps_.socket_factory->AddSocketDataProvider(&data); 8389 session_deps_.socket_factory->AddSocketDataProvider(&data);
8390 8390
8391 TestCompletionCallback callback; 8391 TestCompletionCallback callback;
8392 8392
8393 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8393 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8394 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8394 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8395 8395
8396 rv = callback.WaitForResult(); 8396 rv = callback.WaitForResult();
8397 EXPECT_THAT(rv, IsOk()); 8397 EXPECT_THAT(rv, IsOk());
8398 } 8398 }
8399 8399
8400 TEST_F(HttpNetworkTransactionTest, BuildRequest_PostContentLengthZero) { 8400 TEST_F(HttpNetworkTransactionTest, BuildRequest_PostContentLengthZero) {
8401 HttpRequestInfo request; 8401 HttpRequestInfo request;
8402 request.method = "POST"; 8402 request.method = "POST";
8403 request.url = GURL("http://www.example.org/"); 8403 request.url = GURL("http://www.example.org/");
(...skipping 16 matching lines...) Expand all
8420 MockRead("Content-Length: 100\r\n\r\n"), 8420 MockRead("Content-Length: 100\r\n\r\n"),
8421 MockRead(SYNCHRONOUS, OK), 8421 MockRead(SYNCHRONOUS, OK),
8422 }; 8422 };
8423 8423
8424 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8424 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8425 data_writes, arraysize(data_writes)); 8425 data_writes, arraysize(data_writes));
8426 session_deps_.socket_factory->AddSocketDataProvider(&data); 8426 session_deps_.socket_factory->AddSocketDataProvider(&data);
8427 8427
8428 TestCompletionCallback callback; 8428 TestCompletionCallback callback;
8429 8429
8430 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8430 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8431 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8431 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8432 8432
8433 rv = callback.WaitForResult(); 8433 rv = callback.WaitForResult();
8434 EXPECT_THAT(rv, IsOk()); 8434 EXPECT_THAT(rv, IsOk());
8435 } 8435 }
8436 8436
8437 TEST_F(HttpNetworkTransactionTest, BuildRequest_PutContentLengthZero) { 8437 TEST_F(HttpNetworkTransactionTest, BuildRequest_PutContentLengthZero) {
8438 HttpRequestInfo request; 8438 HttpRequestInfo request;
8439 request.method = "PUT"; 8439 request.method = "PUT";
8440 request.url = GURL("http://www.example.org/"); 8440 request.url = GURL("http://www.example.org/");
(...skipping 16 matching lines...) Expand all
8457 MockRead("Content-Length: 100\r\n\r\n"), 8457 MockRead("Content-Length: 100\r\n\r\n"),
8458 MockRead(SYNCHRONOUS, OK), 8458 MockRead(SYNCHRONOUS, OK),
8459 }; 8459 };
8460 8460
8461 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8461 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8462 data_writes, arraysize(data_writes)); 8462 data_writes, arraysize(data_writes));
8463 session_deps_.socket_factory->AddSocketDataProvider(&data); 8463 session_deps_.socket_factory->AddSocketDataProvider(&data);
8464 8464
8465 TestCompletionCallback callback; 8465 TestCompletionCallback callback;
8466 8466
8467 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8467 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8468 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8468 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8469 8469
8470 rv = callback.WaitForResult(); 8470 rv = callback.WaitForResult();
8471 EXPECT_THAT(rv, IsOk()); 8471 EXPECT_THAT(rv, IsOk());
8472 } 8472 }
8473 8473
8474 TEST_F(HttpNetworkTransactionTest, BuildRequest_HeadContentLengthZero) { 8474 TEST_F(HttpNetworkTransactionTest, BuildRequest_HeadContentLengthZero) {
8475 HttpRequestInfo request; 8475 HttpRequestInfo request;
8476 request.method = "HEAD"; 8476 request.method = "HEAD";
8477 request.url = GURL("http://www.example.org/"); 8477 request.url = GURL("http://www.example.org/");
(...skipping 14 matching lines...) Expand all
8492 MockRead("Content-Length: 100\r\n\r\n"), 8492 MockRead("Content-Length: 100\r\n\r\n"),
8493 MockRead(SYNCHRONOUS, OK), 8493 MockRead(SYNCHRONOUS, OK),
8494 }; 8494 };
8495 8495
8496 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8496 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8497 data_writes, arraysize(data_writes)); 8497 data_writes, arraysize(data_writes));
8498 session_deps_.socket_factory->AddSocketDataProvider(&data); 8498 session_deps_.socket_factory->AddSocketDataProvider(&data);
8499 8499
8500 TestCompletionCallback callback; 8500 TestCompletionCallback callback;
8501 8501
8502 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8502 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8503 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8503 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8504 8504
8505 rv = callback.WaitForResult(); 8505 rv = callback.WaitForResult();
8506 EXPECT_THAT(rv, IsOk()); 8506 EXPECT_THAT(rv, IsOk());
8507 } 8507 }
8508 8508
8509 TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlNoCache) { 8509 TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlNoCache) {
8510 HttpRequestInfo request; 8510 HttpRequestInfo request;
8511 request.method = "GET"; 8511 request.method = "GET";
8512 request.url = GURL("http://www.example.org/"); 8512 request.url = GURL("http://www.example.org/");
(...skipping 18 matching lines...) Expand all
8531 MockRead("Content-Length: 100\r\n\r\n"), 8531 MockRead("Content-Length: 100\r\n\r\n"),
8532 MockRead(SYNCHRONOUS, OK), 8532 MockRead(SYNCHRONOUS, OK),
8533 }; 8533 };
8534 8534
8535 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8535 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8536 data_writes, arraysize(data_writes)); 8536 data_writes, arraysize(data_writes));
8537 session_deps_.socket_factory->AddSocketDataProvider(&data); 8537 session_deps_.socket_factory->AddSocketDataProvider(&data);
8538 8538
8539 TestCompletionCallback callback; 8539 TestCompletionCallback callback;
8540 8540
8541 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8541 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8542 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8542 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8543 8543
8544 rv = callback.WaitForResult(); 8544 rv = callback.WaitForResult();
8545 EXPECT_THAT(rv, IsOk()); 8545 EXPECT_THAT(rv, IsOk());
8546 } 8546 }
8547 8547
8548 TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlValidateCache) { 8548 TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlValidateCache) {
8549 HttpRequestInfo request; 8549 HttpRequestInfo request;
8550 request.method = "GET"; 8550 request.method = "GET";
8551 request.url = GURL("http://www.example.org/"); 8551 request.url = GURL("http://www.example.org/");
(...skipping 17 matching lines...) Expand all
8569 MockRead("Content-Length: 100\r\n\r\n"), 8569 MockRead("Content-Length: 100\r\n\r\n"),
8570 MockRead(SYNCHRONOUS, OK), 8570 MockRead(SYNCHRONOUS, OK),
8571 }; 8571 };
8572 8572
8573 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8573 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8574 data_writes, arraysize(data_writes)); 8574 data_writes, arraysize(data_writes));
8575 session_deps_.socket_factory->AddSocketDataProvider(&data); 8575 session_deps_.socket_factory->AddSocketDataProvider(&data);
8576 8576
8577 TestCompletionCallback callback; 8577 TestCompletionCallback callback;
8578 8578
8579 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8579 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8580 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8580 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8581 8581
8582 rv = callback.WaitForResult(); 8582 rv = callback.WaitForResult();
8583 EXPECT_THAT(rv, IsOk()); 8583 EXPECT_THAT(rv, IsOk());
8584 } 8584 }
8585 8585
8586 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeaders) { 8586 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeaders) {
8587 HttpRequestInfo request; 8587 HttpRequestInfo request;
8588 request.method = "GET"; 8588 request.method = "GET";
8589 request.url = GURL("http://www.example.org/"); 8589 request.url = GURL("http://www.example.org/");
(...skipping 17 matching lines...) Expand all
8607 MockRead("Content-Length: 100\r\n\r\n"), 8607 MockRead("Content-Length: 100\r\n\r\n"),
8608 MockRead(SYNCHRONOUS, OK), 8608 MockRead(SYNCHRONOUS, OK),
8609 }; 8609 };
8610 8610
8611 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8611 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8612 data_writes, arraysize(data_writes)); 8612 data_writes, arraysize(data_writes));
8613 session_deps_.socket_factory->AddSocketDataProvider(&data); 8613 session_deps_.socket_factory->AddSocketDataProvider(&data);
8614 8614
8615 TestCompletionCallback callback; 8615 TestCompletionCallback callback;
8616 8616
8617 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8617 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8618 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8618 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8619 8619
8620 rv = callback.WaitForResult(); 8620 rv = callback.WaitForResult();
8621 EXPECT_THAT(rv, IsOk()); 8621 EXPECT_THAT(rv, IsOk());
8622 } 8622 }
8623 8623
8624 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeadersStripped) { 8624 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeadersStripped) {
8625 HttpRequestInfo request; 8625 HttpRequestInfo request;
8626 request.method = "GET"; 8626 request.method = "GET";
8627 request.url = GURL("http://www.example.org/"); 8627 request.url = GURL("http://www.example.org/");
(...skipping 21 matching lines...) Expand all
8649 MockRead("Content-Length: 100\r\n\r\n"), 8649 MockRead("Content-Length: 100\r\n\r\n"),
8650 MockRead(SYNCHRONOUS, OK), 8650 MockRead(SYNCHRONOUS, OK),
8651 }; 8651 };
8652 8652
8653 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8653 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8654 data_writes, arraysize(data_writes)); 8654 data_writes, arraysize(data_writes));
8655 session_deps_.socket_factory->AddSocketDataProvider(&data); 8655 session_deps_.socket_factory->AddSocketDataProvider(&data);
8656 8656
8657 TestCompletionCallback callback; 8657 TestCompletionCallback callback;
8658 8658
8659 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8659 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8660 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8660 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8661 8661
8662 rv = callback.WaitForResult(); 8662 rv = callback.WaitForResult();
8663 EXPECT_THAT(rv, IsOk()); 8663 EXPECT_THAT(rv, IsOk());
8664 } 8664 }
8665 8665
8666 TEST_F(HttpNetworkTransactionTest, SOCKS4_HTTP_GET) { 8666 TEST_F(HttpNetworkTransactionTest, SOCKS4_HTTP_GET) {
8667 HttpRequestInfo request; 8667 HttpRequestInfo request;
8668 request.method = "GET"; 8668 request.method = "GET";
8669 request.url = GURL("http://www.example.org/"); 8669 request.url = GURL("http://www.example.org/");
(...skipping 24 matching lines...) Expand all
8694 MockRead("Payload"), 8694 MockRead("Payload"),
8695 MockRead(SYNCHRONOUS, OK) 8695 MockRead(SYNCHRONOUS, OK)
8696 }; 8696 };
8697 8697
8698 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8698 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8699 data_writes, arraysize(data_writes)); 8699 data_writes, arraysize(data_writes));
8700 session_deps_.socket_factory->AddSocketDataProvider(&data); 8700 session_deps_.socket_factory->AddSocketDataProvider(&data);
8701 8701
8702 TestCompletionCallback callback; 8702 TestCompletionCallback callback;
8703 8703
8704 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8704 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8705 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8705 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8706 8706
8707 rv = callback.WaitForResult(); 8707 rv = callback.WaitForResult();
8708 EXPECT_THAT(rv, IsOk()); 8708 EXPECT_THAT(rv, IsOk());
8709 8709
8710 const HttpResponseInfo* response = trans.GetResponseInfo(); 8710 const HttpResponseInfo* response = trans.GetResponseInfo();
8711 ASSERT_TRUE(response); 8711 ASSERT_TRUE(response);
8712 8712
8713 LoadTimingInfo load_timing_info; 8713 LoadTimingInfo load_timing_info;
8714 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 8714 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
8757 8757
8758 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8758 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8759 data_writes, arraysize(data_writes)); 8759 data_writes, arraysize(data_writes));
8760 session_deps_.socket_factory->AddSocketDataProvider(&data); 8760 session_deps_.socket_factory->AddSocketDataProvider(&data);
8761 8761
8762 SSLSocketDataProvider ssl(ASYNC, OK); 8762 SSLSocketDataProvider ssl(ASYNC, OK);
8763 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 8763 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
8764 8764
8765 TestCompletionCallback callback; 8765 TestCompletionCallback callback;
8766 8766
8767 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8767 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8768 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8768 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8769 8769
8770 rv = callback.WaitForResult(); 8770 rv = callback.WaitForResult();
8771 EXPECT_THAT(rv, IsOk()); 8771 EXPECT_THAT(rv, IsOk());
8772 8772
8773 LoadTimingInfo load_timing_info; 8773 LoadTimingInfo load_timing_info;
8774 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 8774 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
8775 TestLoadTimingNotReusedWithPac(load_timing_info, 8775 TestLoadTimingNotReusedWithPac(load_timing_info,
8776 CONNECT_TIMING_HAS_SSL_TIMES); 8776 CONNECT_TIMING_HAS_SSL_TIMES);
8777 8777
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
8815 MockRead("Payload"), 8815 MockRead("Payload"),
8816 MockRead(SYNCHRONOUS, OK) 8816 MockRead(SYNCHRONOUS, OK)
8817 }; 8817 };
8818 8818
8819 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8819 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8820 data_writes, arraysize(data_writes)); 8820 data_writes, arraysize(data_writes));
8821 session_deps_.socket_factory->AddSocketDataProvider(&data); 8821 session_deps_.socket_factory->AddSocketDataProvider(&data);
8822 8822
8823 TestCompletionCallback callback; 8823 TestCompletionCallback callback;
8824 8824
8825 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8825 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8826 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8826 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8827 8827
8828 rv = callback.WaitForResult(); 8828 rv = callback.WaitForResult();
8829 EXPECT_THAT(rv, IsOk()); 8829 EXPECT_THAT(rv, IsOk());
8830 8830
8831 const HttpResponseInfo* response = trans.GetResponseInfo(); 8831 const HttpResponseInfo* response = trans.GetResponseInfo();
8832 ASSERT_TRUE(response); 8832 ASSERT_TRUE(response);
8833 8833
8834 LoadTimingInfo load_timing_info; 8834 LoadTimingInfo load_timing_info;
8835 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 8835 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
8886 MockRead("Payload"), 8886 MockRead("Payload"),
8887 MockRead(SYNCHRONOUS, OK) 8887 MockRead(SYNCHRONOUS, OK)
8888 }; 8888 };
8889 8889
8890 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8890 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8891 data_writes, arraysize(data_writes)); 8891 data_writes, arraysize(data_writes));
8892 session_deps_.socket_factory->AddSocketDataProvider(&data); 8892 session_deps_.socket_factory->AddSocketDataProvider(&data);
8893 8893
8894 TestCompletionCallback callback; 8894 TestCompletionCallback callback;
8895 8895
8896 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8896 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8897 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8897 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8898 8898
8899 rv = callback.WaitForResult(); 8899 rv = callback.WaitForResult();
8900 EXPECT_THAT(rv, IsOk()); 8900 EXPECT_THAT(rv, IsOk());
8901 8901
8902 const HttpResponseInfo* response = trans.GetResponseInfo(); 8902 const HttpResponseInfo* response = trans.GetResponseInfo();
8903 ASSERT_TRUE(response); 8903 ASSERT_TRUE(response);
8904 8904
8905 LoadTimingInfo load_timing_info; 8905 LoadTimingInfo load_timing_info;
8906 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 8906 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
8962 8962
8963 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 8963 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
8964 data_writes, arraysize(data_writes)); 8964 data_writes, arraysize(data_writes));
8965 session_deps_.socket_factory->AddSocketDataProvider(&data); 8965 session_deps_.socket_factory->AddSocketDataProvider(&data);
8966 8966
8967 SSLSocketDataProvider ssl(ASYNC, OK); 8967 SSLSocketDataProvider ssl(ASYNC, OK);
8968 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 8968 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
8969 8969
8970 TestCompletionCallback callback; 8970 TestCompletionCallback callback;
8971 8971
8972 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 8972 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
8973 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 8973 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
8974 8974
8975 rv = callback.WaitForResult(); 8975 rv = callback.WaitForResult();
8976 EXPECT_THAT(rv, IsOk()); 8976 EXPECT_THAT(rv, IsOk());
8977 8977
8978 const HttpResponseInfo* response = trans.GetResponseInfo(); 8978 const HttpResponseInfo* response = trans.GetResponseInfo();
8979 ASSERT_TRUE(response); 8979 ASSERT_TRUE(response);
8980 8980
8981 LoadTimingInfo load_timing_info; 8981 LoadTimingInfo load_timing_info;
8982 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info)); 8982 EXPECT_TRUE(trans.GetLoadTimingInfo(&load_timing_info));
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
9021 HttpRequestInfo request; 9021 HttpRequestInfo request;
9022 request.method = "GET"; 9022 request.method = "GET";
9023 request.url = GURL(url); 9023 request.url = GURL(url);
9024 request.load_flags = 0; 9024 request.load_flags = 0;
9025 9025
9026 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session); 9026 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session);
9027 9027
9028 TestCompletionCallback callback; 9028 TestCompletionCallback callback;
9029 9029
9030 // We do not complete this request, the dtor will clean the transaction up. 9030 // We do not complete this request, the dtor will clean the transaction up.
9031 return trans.Start(&request, callback.callback(), BoundNetLog()); 9031 return trans.Start(&request, callback.callback(), NetLogWithSource());
9032 } 9032 }
9033 9033
9034 } // namespace 9034 } // namespace
9035 9035
9036 TEST_F(HttpNetworkTransactionTest, GroupNameForDirectConnections) { 9036 TEST_F(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
9037 const GroupNameTest tests[] = { 9037 const GroupNameTest tests[] = {
9038 { 9038 {
9039 "", // unused 9039 "", // unused
9040 "http://www.example.org/direct", 9040 "http://www.example.org/direct",
9041 "www.example.org:80", 9041 "www.example.org:80",
(...skipping 198 matching lines...) Expand 10 before | Expand all | Expand 10 after
9240 9240
9241 // This simulates failure resolving all hostnames; that means we will fail 9241 // This simulates failure resolving all hostnames; that means we will fail
9242 // connecting to both proxies (myproxy:70 and foobar:80). 9242 // connecting to both proxies (myproxy:70 and foobar:80).
9243 session_deps_.host_resolver->rules()->AddSimulatedFailure("*"); 9243 session_deps_.host_resolver->rules()->AddSimulatedFailure("*");
9244 9244
9245 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9245 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9246 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9246 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9247 9247
9248 TestCompletionCallback callback; 9248 TestCompletionCallback callback;
9249 9249
9250 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9250 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9251 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9251 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9252 9252
9253 rv = callback.WaitForResult(); 9253 rv = callback.WaitForResult();
9254 EXPECT_THAT(rv, IsError(ERR_PROXY_CONNECTION_FAILED)); 9254 EXPECT_THAT(rv, IsError(ERR_PROXY_CONNECTION_FAILED));
9255 } 9255 }
9256 9256
9257 // Base test to make sure that when the load flags for a request specify to 9257 // Base test to make sure that when the load flags for a request specify to
9258 // bypass the cache, the DNS cache is not used. 9258 // bypass the cache, the DNS cache is not used.
9259 void HttpNetworkTransactionTest::BypassHostCacheOnRefreshHelper( 9259 void HttpNetworkTransactionTest::BypassHostCacheOnRefreshHelper(
9260 int load_flags) { 9260 int load_flags) {
9261 // Issue a request, asking to bypass the cache(s). 9261 // Issue a request, asking to bypass the cache(s).
9262 HttpRequestInfo request_info; 9262 HttpRequestInfo request_info;
9263 request_info.method = "GET"; 9263 request_info.method = "GET";
9264 request_info.load_flags = load_flags; 9264 request_info.load_flags = load_flags;
9265 request_info.url = GURL("http://www.example.org/"); 9265 request_info.url = GURL("http://www.example.org/");
9266 9266
9267 // Select a host resolver that does caching. 9267 // Select a host resolver that does caching.
9268 session_deps_.host_resolver.reset(new MockCachingHostResolver); 9268 session_deps_.host_resolver.reset(new MockCachingHostResolver);
9269 9269
9270 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9270 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9271 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9271 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9272 9272
9273 // Warm up the host cache so it has an entry for "www.example.org". 9273 // Warm up the host cache so it has an entry for "www.example.org".
9274 AddressList addrlist; 9274 AddressList addrlist;
9275 TestCompletionCallback callback; 9275 TestCompletionCallback callback;
9276 std::unique_ptr<HostResolver::Request> request1; 9276 std::unique_ptr<HostResolver::Request> request1;
9277 int rv = session_deps_.host_resolver->Resolve( 9277 int rv = session_deps_.host_resolver->Resolve(
9278 HostResolver::RequestInfo(HostPortPair("www.example.org", 80)), 9278 HostResolver::RequestInfo(HostPortPair("www.example.org", 80)),
9279 DEFAULT_PRIORITY, &addrlist, callback.callback(), &request1, 9279 DEFAULT_PRIORITY, &addrlist, callback.callback(), &request1,
9280 BoundNetLog()); 9280 NetLogWithSource());
9281 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9281 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9282 rv = callback.WaitForResult(); 9282 rv = callback.WaitForResult();
9283 EXPECT_THAT(rv, IsOk()); 9283 EXPECT_THAT(rv, IsOk());
9284 9284
9285 // Verify that it was added to host cache, by doing a subsequent async lookup 9285 // Verify that it was added to host cache, by doing a subsequent async lookup
9286 // and confirming it completes synchronously. 9286 // and confirming it completes synchronously.
9287 std::unique_ptr<HostResolver::Request> request2; 9287 std::unique_ptr<HostResolver::Request> request2;
9288 rv = session_deps_.host_resolver->Resolve( 9288 rv = session_deps_.host_resolver->Resolve(
9289 HostResolver::RequestInfo(HostPortPair("www.example.org", 80)), 9289 HostResolver::RequestInfo(HostPortPair("www.example.org", 80)),
9290 DEFAULT_PRIORITY, &addrlist, callback.callback(), &request2, 9290 DEFAULT_PRIORITY, &addrlist, callback.callback(), &request2,
9291 BoundNetLog()); 9291 NetLogWithSource());
9292 ASSERT_THAT(rv, IsOk()); 9292 ASSERT_THAT(rv, IsOk());
9293 9293
9294 // Inject a failure the next time that "www.example.org" is resolved. This way 9294 // Inject a failure the next time that "www.example.org" is resolved. This way
9295 // we can tell if the next lookup hit the cache, or the "network". 9295 // we can tell if the next lookup hit the cache, or the "network".
9296 // (cache --> success, "network" --> failure). 9296 // (cache --> success, "network" --> failure).
9297 session_deps_.host_resolver->rules()->AddSimulatedFailure("www.example.org"); 9297 session_deps_.host_resolver->rules()->AddSimulatedFailure("www.example.org");
9298 9298
9299 // Connect up a mock socket which will fail with ERR_UNEXPECTED during the 9299 // Connect up a mock socket which will fail with ERR_UNEXPECTED during the
9300 // first read -- this won't be reached as the host resolution will fail first. 9300 // first read -- this won't be reached as the host resolution will fail first.
9301 MockRead data_reads[] = { MockRead(SYNCHRONOUS, ERR_UNEXPECTED) }; 9301 MockRead data_reads[] = { MockRead(SYNCHRONOUS, ERR_UNEXPECTED) };
9302 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 9302 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
9303 session_deps_.socket_factory->AddSocketDataProvider(&data); 9303 session_deps_.socket_factory->AddSocketDataProvider(&data);
9304 9304
9305 // Run the request. 9305 // Run the request.
9306 rv = trans.Start(&request_info, callback.callback(), BoundNetLog()); 9306 rv = trans.Start(&request_info, callback.callback(), NetLogWithSource());
9307 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 9307 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
9308 rv = callback.WaitForResult(); 9308 rv = callback.WaitForResult();
9309 9309
9310 // If we bypassed the cache, we would have gotten a failure while resolving 9310 // If we bypassed the cache, we would have gotten a failure while resolving
9311 // "www.example.org". 9311 // "www.example.org".
9312 EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED)); 9312 EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED));
9313 } 9313 }
9314 9314
9315 // There are multiple load flags that should trigger the host cache bypass. 9315 // There are multiple load flags that should trigger the host cache bypass.
9316 // Test each in isolation: 9316 // Test each in isolation:
(...skipping 21 matching lines...) Expand all
9338 }; 9338 };
9339 StaticSocketDataProvider data(NULL, 0, 9339 StaticSocketDataProvider data(NULL, 0,
9340 write_failure, arraysize(write_failure)); 9340 write_failure, arraysize(write_failure));
9341 session_deps_.socket_factory->AddSocketDataProvider(&data); 9341 session_deps_.socket_factory->AddSocketDataProvider(&data);
9342 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9342 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9343 9343
9344 TestCompletionCallback callback; 9344 TestCompletionCallback callback;
9345 9345
9346 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9346 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9347 9347
9348 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9348 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9349 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9349 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9350 9350
9351 rv = callback.WaitForResult(); 9351 rv = callback.WaitForResult();
9352 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 9352 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
9353 9353
9354 IPEndPoint endpoint; 9354 IPEndPoint endpoint;
9355 EXPECT_TRUE(trans.GetRemoteEndpoint(&endpoint)); 9355 EXPECT_TRUE(trans.GetRemoteEndpoint(&endpoint));
9356 EXPECT_LT(0u, endpoint.address().size()); 9356 EXPECT_LT(0u, endpoint.address().size());
9357 } 9357 }
9358 9358
(...skipping 10 matching lines...) Expand all
9369 }; 9369 };
9370 9370
9371 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 9371 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
9372 session_deps_.socket_factory->AddSocketDataProvider(&data); 9372 session_deps_.socket_factory->AddSocketDataProvider(&data);
9373 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9373 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9374 9374
9375 TestCompletionCallback callback; 9375 TestCompletionCallback callback;
9376 9376
9377 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9377 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9378 9378
9379 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9379 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9380 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9380 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9381 9381
9382 rv = callback.WaitForResult(); 9382 rv = callback.WaitForResult();
9383 EXPECT_THAT(rv, IsOk()); 9383 EXPECT_THAT(rv, IsOk());
9384 9384
9385 const HttpResponseInfo* response = trans.GetResponseInfo(); 9385 const HttpResponseInfo* response = trans.GetResponseInfo();
9386 ASSERT_TRUE(response); 9386 ASSERT_TRUE(response);
9387 9387
9388 EXPECT_TRUE(response->headers); 9388 EXPECT_TRUE(response->headers);
9389 EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine()); 9389 EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
9446 9446
9447 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), 9447 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
9448 data_writes2, arraysize(data_writes2)); 9448 data_writes2, arraysize(data_writes2));
9449 session_deps_.socket_factory->AddSocketDataProvider(&data2); 9449 session_deps_.socket_factory->AddSocketDataProvider(&data2);
9450 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9450 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9451 9451
9452 TestCompletionCallback callback1; 9452 TestCompletionCallback callback1;
9453 9453
9454 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9454 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9455 9455
9456 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 9456 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
9457 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9457 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9458 9458
9459 rv = callback1.WaitForResult(); 9459 rv = callback1.WaitForResult();
9460 EXPECT_THAT(rv, IsOk()); 9460 EXPECT_THAT(rv, IsOk());
9461 9461
9462 const HttpResponseInfo* response = trans.GetResponseInfo(); 9462 const HttpResponseInfo* response = trans.GetResponseInfo();
9463 ASSERT_TRUE(response); 9463 ASSERT_TRUE(response);
9464 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get())); 9464 EXPECT_TRUE(CheckBasicServerAuth(response->auth_challenge.get()));
9465 9465
9466 TestCompletionCallback callback2; 9466 TestCompletionCallback callback2;
(...skipping 30 matching lines...) Expand all
9497 session_deps_.socket_factory->AddSocketDataProvider(&data); 9497 session_deps_.socket_factory->AddSocketDataProvider(&data);
9498 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 9498 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
9499 9499
9500 TestCompletionCallback callback; 9500 TestCompletionCallback callback;
9501 9501
9502 session_deps_.socket_factory->ResetNextMockIndexes(); 9502 session_deps_.socket_factory->ResetNextMockIndexes();
9503 9503
9504 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9504 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9505 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9505 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9506 9506
9507 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9507 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9508 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9508 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9509 9509
9510 rv = callback.WaitForResult(); 9510 rv = callback.WaitForResult();
9511 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED)); 9511 EXPECT_THAT(rv, IsError(ERR_TUNNEL_CONNECTION_FAILED));
9512 } 9512 }
9513 9513
9514 TEST_F(HttpNetworkTransactionTest, LargeContentLengthThenClose) { 9514 TEST_F(HttpNetworkTransactionTest, LargeContentLengthThenClose) {
9515 HttpRequestInfo request; 9515 HttpRequestInfo request;
9516 request.method = "GET"; 9516 request.method = "GET";
9517 request.url = GURL("http://www.example.org/"); 9517 request.url = GURL("http://www.example.org/");
9518 request.load_flags = 0; 9518 request.load_flags = 0;
9519 9519
9520 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9520 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9521 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9521 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9522 9522
9523 MockRead data_reads[] = { 9523 MockRead data_reads[] = {
9524 MockRead("HTTP/1.0 200 OK\r\nContent-Length:6719476739\r\n\r\n"), 9524 MockRead("HTTP/1.0 200 OK\r\nContent-Length:6719476739\r\n\r\n"),
9525 MockRead(SYNCHRONOUS, OK), 9525 MockRead(SYNCHRONOUS, OK),
9526 }; 9526 };
9527 9527
9528 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 9528 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
9529 session_deps_.socket_factory->AddSocketDataProvider(&data); 9529 session_deps_.socket_factory->AddSocketDataProvider(&data);
9530 9530
9531 TestCompletionCallback callback; 9531 TestCompletionCallback callback;
9532 9532
9533 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9533 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9534 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9534 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9535 9535
9536 EXPECT_THAT(callback.WaitForResult(), IsOk()); 9536 EXPECT_THAT(callback.WaitForResult(), IsOk());
9537 9537
9538 const HttpResponseInfo* response = trans.GetResponseInfo(); 9538 const HttpResponseInfo* response = trans.GetResponseInfo();
9539 ASSERT_TRUE(response); 9539 ASSERT_TRUE(response);
9540 9540
9541 EXPECT_TRUE(response->headers); 9541 EXPECT_TRUE(response->headers);
9542 EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine()); 9542 EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
9543 9543
(...skipping 27 matching lines...) Expand all
9571 MockRead data_reads[] = { 9571 MockRead data_reads[] = {
9572 MockRead("HTTP/1.0 200 OK\r\n\r\n"), 9572 MockRead("HTTP/1.0 200 OK\r\n\r\n"),
9573 MockRead("hello world"), 9573 MockRead("hello world"),
9574 MockRead(SYNCHRONOUS, OK), 9574 MockRead(SYNCHRONOUS, OK),
9575 }; 9575 };
9576 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0); 9576 StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
9577 session_deps_.socket_factory->AddSocketDataProvider(&data); 9577 session_deps_.socket_factory->AddSocketDataProvider(&data);
9578 9578
9579 TestCompletionCallback callback; 9579 TestCompletionCallback callback;
9580 9580
9581 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9581 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9582 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9582 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9583 9583
9584 rv = callback.WaitForResult(); 9584 rv = callback.WaitForResult();
9585 EXPECT_THAT(rv, IsError(ERR_UPLOAD_FILE_CHANGED)); 9585 EXPECT_THAT(rv, IsError(ERR_UPLOAD_FILE_CHANGED));
9586 9586
9587 const HttpResponseInfo* response = trans.GetResponseInfo(); 9587 const HttpResponseInfo* response = trans.GetResponseInfo();
9588 ASSERT_TRUE(response); 9588 ASSERT_TRUE(response);
9589 9589
9590 EXPECT_FALSE(response->headers); 9590 EXPECT_FALSE(response->headers);
9591 9591
(...skipping 22 matching lines...) Expand all
9614 9614
9615 // If we try to upload an unreadable file, the transaction should fail. 9615 // If we try to upload an unreadable file, the transaction should fail.
9616 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9616 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9617 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9617 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9618 9618
9619 StaticSocketDataProvider data(NULL, 0, NULL, 0); 9619 StaticSocketDataProvider data(NULL, 0, NULL, 0);
9620 session_deps_.socket_factory->AddSocketDataProvider(&data); 9620 session_deps_.socket_factory->AddSocketDataProvider(&data);
9621 9621
9622 TestCompletionCallback callback; 9622 TestCompletionCallback callback;
9623 9623
9624 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9624 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9625 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9625 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9626 9626
9627 rv = callback.WaitForResult(); 9627 rv = callback.WaitForResult();
9628 EXPECT_THAT(rv, IsError(ERR_ACCESS_DENIED)); 9628 EXPECT_THAT(rv, IsError(ERR_ACCESS_DENIED));
9629 9629
9630 base::DeleteFile(temp_file, false); 9630 base::DeleteFile(temp_file, false);
9631 } 9631 }
9632 9632
9633 TEST_F(HttpNetworkTransactionTest, CancelDuringInitRequestBody) { 9633 TEST_F(HttpNetworkTransactionTest, CancelDuringInitRequestBody) {
9634 class FakeUploadElementReader : public UploadElementReader { 9634 class FakeUploadElementReader : public UploadElementReader {
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
9667 request.load_flags = 0; 9667 request.load_flags = 0;
9668 9668
9669 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9669 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9670 std::unique_ptr<HttpNetworkTransaction> trans( 9670 std::unique_ptr<HttpNetworkTransaction> trans(
9671 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 9671 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
9672 9672
9673 StaticSocketDataProvider data; 9673 StaticSocketDataProvider data;
9674 session_deps_.socket_factory->AddSocketDataProvider(&data); 9674 session_deps_.socket_factory->AddSocketDataProvider(&data);
9675 9675
9676 TestCompletionCallback callback; 9676 TestCompletionCallback callback;
9677 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 9677 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
9678 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9678 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9679 base::RunLoop().RunUntilIdle(); 9679 base::RunLoop().RunUntilIdle();
9680 9680
9681 // Transaction is pending on request body initialization. 9681 // Transaction is pending on request body initialization.
9682 ASSERT_FALSE(fake_reader->callback().is_null()); 9682 ASSERT_FALSE(fake_reader->callback().is_null());
9683 9683
9684 // Return Init()'s result after the transaction gets destroyed. 9684 // Return Init()'s result after the transaction gets destroyed.
9685 trans.reset(); 9685 trans.reset();
9686 fake_reader->callback().Run(OK); // Should not crash. 9686 fake_reader->callback().Run(OK); // Should not crash.
9687 } 9687 }
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
9772 session_deps_.socket_factory->AddSocketDataProvider(&data4); 9772 session_deps_.socket_factory->AddSocketDataProvider(&data4);
9773 9773
9774 TestCompletionCallback callback1; 9774 TestCompletionCallback callback1;
9775 9775
9776 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9776 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9777 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9777 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9778 9778
9779 // Issue the first request with Authorize headers. There should be a 9779 // Issue the first request with Authorize headers. There should be a
9780 // password prompt for first_realm waiting to be filled in after the 9780 // password prompt for first_realm waiting to be filled in after the
9781 // transaction completes. 9781 // transaction completes.
9782 int rv = trans.Start(&request, callback1.callback(), BoundNetLog()); 9782 int rv = trans.Start(&request, callback1.callback(), NetLogWithSource());
9783 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9783 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9784 rv = callback1.WaitForResult(); 9784 rv = callback1.WaitForResult();
9785 EXPECT_THAT(rv, IsOk()); 9785 EXPECT_THAT(rv, IsOk());
9786 const HttpResponseInfo* response = trans.GetResponseInfo(); 9786 const HttpResponseInfo* response = trans.GetResponseInfo();
9787 ASSERT_TRUE(response); 9787 ASSERT_TRUE(response);
9788 const AuthChallengeInfo* challenge = response->auth_challenge.get(); 9788 const AuthChallengeInfo* challenge = response->auth_challenge.get();
9789 ASSERT_TRUE(challenge); 9789 ASSERT_TRUE(challenge);
9790 EXPECT_FALSE(challenge->is_proxy); 9790 EXPECT_FALSE(challenge->is_proxy);
9791 EXPECT_EQ("http://www.example.org", challenge->challenger.Serialize()); 9791 EXPECT_EQ("http://www.example.org", challenge->challenger.Serialize());
9792 EXPECT_EQ("first_realm", challenge->realm); 9792 EXPECT_EQ("first_realm", challenge->realm);
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after
9859 session_deps_.socket_factory->AddSocketDataProvider(&data); 9859 session_deps_.socket_factory->AddSocketDataProvider(&data);
9860 9860
9861 SSLSocketDataProvider ssl(ASYNC, OK); 9861 SSLSocketDataProvider ssl(ASYNC, OK);
9862 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 9862 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
9863 9863
9864 TestCompletionCallback callback; 9864 TestCompletionCallback callback;
9865 9865
9866 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9866 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9867 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9867 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9868 9868
9869 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9869 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9870 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9870 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9871 9871
9872 url::SchemeHostPort test_server(request.url); 9872 url::SchemeHostPort test_server(request.url);
9873 HttpServerProperties* http_server_properties = 9873 HttpServerProperties* http_server_properties =
9874 session->http_server_properties(); 9874 session->http_server_properties();
9875 AlternativeServiceVector alternative_service_vector = 9875 AlternativeServiceVector alternative_service_vector =
9876 http_server_properties->GetAlternativeServices(test_server); 9876 http_server_properties->GetAlternativeServices(test_server);
9877 EXPECT_TRUE(alternative_service_vector.empty()); 9877 EXPECT_TRUE(alternative_service_vector.empty());
9878 9878
9879 EXPECT_THAT(callback.WaitForResult(), IsOk()); 9879 EXPECT_THAT(callback.WaitForResult(), IsOk());
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
9922 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 9922 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
9923 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9923 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9924 9924
9925 url::SchemeHostPort test_server(request.url); 9925 url::SchemeHostPort test_server(request.url);
9926 HttpServerProperties* http_server_properties = 9926 HttpServerProperties* http_server_properties =
9927 session->http_server_properties(); 9927 session->http_server_properties();
9928 AlternativeServiceVector alternative_service_vector = 9928 AlternativeServiceVector alternative_service_vector =
9929 http_server_properties->GetAlternativeServices(test_server); 9929 http_server_properties->GetAlternativeServices(test_server);
9930 EXPECT_TRUE(alternative_service_vector.empty()); 9930 EXPECT_TRUE(alternative_service_vector.empty());
9931 9931
9932 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9932 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9933 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 9933 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
9934 EXPECT_THAT(callback.WaitForResult(), IsOk()); 9934 EXPECT_THAT(callback.WaitForResult(), IsOk());
9935 9935
9936 const HttpResponseInfo* response = trans.GetResponseInfo(); 9936 const HttpResponseInfo* response = trans.GetResponseInfo();
9937 ASSERT_TRUE(response); 9937 ASSERT_TRUE(response);
9938 ASSERT_TRUE(response->headers); 9938 ASSERT_TRUE(response->headers);
9939 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 9939 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
9940 EXPECT_FALSE(response->was_fetched_via_spdy); 9940 EXPECT_FALSE(response->was_fetched_via_spdy);
9941 EXPECT_FALSE(response->was_alpn_negotiated); 9941 EXPECT_FALSE(response->was_alpn_negotiated);
9942 9942
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
9984 AlternativeService alternative_service( 9984 AlternativeService alternative_service(
9985 AlternateProtocolFromNextProto(kProtoHTTP2), "different.example.org", 9985 AlternateProtocolFromNextProto(kProtoHTTP2), "different.example.org",
9986 444); 9986 444);
9987 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 9987 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
9988 http_server_properties->SetAlternativeService( 9988 http_server_properties->SetAlternativeService(
9989 url::SchemeHostPort(request.url), alternative_service, expiration); 9989 url::SchemeHostPort(request.url), alternative_service, expiration);
9990 9990
9991 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 9991 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
9992 TestCompletionCallback callback; 9992 TestCompletionCallback callback;
9993 9993
9994 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 9994 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
9995 // Alternative service is not used, request fails. 9995 // Alternative service is not used, request fails.
9996 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED)); 9996 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
9997 } 9997 }
9998 9998
9999 // Regression test for https://crbug.com/615497: 9999 // Regression test for https://crbug.com/615497:
10000 // Alternative Services should be disabled for http origin. 10000 // Alternative Services should be disabled for http origin.
10001 TEST_F(HttpNetworkTransactionTest, 10001 TEST_F(HttpNetworkTransactionTest,
10002 DisableAlternativeServicesForInsecureOrigin) { 10002 DisableAlternativeServicesForInsecureOrigin) {
10003 HttpRequestInfo request; 10003 HttpRequestInfo request;
10004 request.method = "GET"; 10004 request.method = "GET";
(...skipping 19 matching lines...) Expand all
10024 session->http_server_properties(); 10024 session->http_server_properties();
10025 AlternativeService alternative_service( 10025 AlternativeService alternative_service(
10026 AlternateProtocolFromNextProto(kProtoHTTP2), "", 444); 10026 AlternateProtocolFromNextProto(kProtoHTTP2), "", 444);
10027 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10027 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10028 http_server_properties->SetAlternativeService( 10028 http_server_properties->SetAlternativeService(
10029 url::SchemeHostPort(request.url), alternative_service, expiration); 10029 url::SchemeHostPort(request.url), alternative_service, expiration);
10030 10030
10031 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10031 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10032 TestCompletionCallback callback; 10032 TestCompletionCallback callback;
10033 10033
10034 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 10034 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
10035 // Alternative service is not used, request fails. 10035 // Alternative service is not used, request fails.
10036 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED)); 10036 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
10037 } 10037 }
10038 10038
10039 TEST_F(HttpNetworkTransactionTest, ClearAlternativeServices) { 10039 TEST_F(HttpNetworkTransactionTest, ClearAlternativeServices) {
10040 // Set an alternative service for origin. 10040 // Set an alternative service for origin.
10041 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 10041 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
10042 HttpServerProperties* http_server_properties = 10042 HttpServerProperties* http_server_properties =
10043 session->http_server_properties(); 10043 session->http_server_properties();
10044 url::SchemeHostPort test_server("https", "www.example.org", 443); 10044 url::SchemeHostPort test_server("https", "www.example.org", 443);
(...skipping 21 matching lines...) Expand all
10066 10066
10067 HttpRequestInfo request; 10067 HttpRequestInfo request;
10068 request.method = "GET"; 10068 request.method = "GET";
10069 request.url = GURL("https://www.example.org/"); 10069 request.url = GURL("https://www.example.org/");
10070 request.load_flags = 0; 10070 request.load_flags = 0;
10071 10071
10072 TestCompletionCallback callback; 10072 TestCompletionCallback callback;
10073 10073
10074 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10074 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10075 10075
10076 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 10076 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
10077 EXPECT_THAT(callback.GetResult(rv), IsOk()); 10077 EXPECT_THAT(callback.GetResult(rv), IsOk());
10078 10078
10079 const HttpResponseInfo* response = trans.GetResponseInfo(); 10079 const HttpResponseInfo* response = trans.GetResponseInfo();
10080 ASSERT_TRUE(response); 10080 ASSERT_TRUE(response);
10081 ASSERT_TRUE(response->headers); 10081 ASSERT_TRUE(response->headers);
10082 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10082 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10083 EXPECT_FALSE(response->was_fetched_via_spdy); 10083 EXPECT_FALSE(response->was_fetched_via_spdy);
10084 EXPECT_FALSE(response->was_alpn_negotiated); 10084 EXPECT_FALSE(response->was_alpn_negotiated);
10085 10085
10086 std::string response_data; 10086 std::string response_data;
(...skipping 23 matching lines...) Expand all
10110 session_deps_.socket_factory->AddSocketDataProvider(&data); 10110 session_deps_.socket_factory->AddSocketDataProvider(&data);
10111 10111
10112 SSLSocketDataProvider ssl(ASYNC, OK); 10112 SSLSocketDataProvider ssl(ASYNC, OK);
10113 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 10113 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
10114 10114
10115 TestCompletionCallback callback; 10115 TestCompletionCallback callback;
10116 10116
10117 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 10117 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
10118 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10118 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10119 10119
10120 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 10120 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
10121 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10121 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10122 10122
10123 url::SchemeHostPort test_server("https", "www.example.org", 443); 10123 url::SchemeHostPort test_server("https", "www.example.org", 443);
10124 HttpServerProperties* http_server_properties = 10124 HttpServerProperties* http_server_properties =
10125 session->http_server_properties(); 10125 session->http_server_properties();
10126 AlternativeServiceVector alternative_service_vector = 10126 AlternativeServiceVector alternative_service_vector =
10127 http_server_properties->GetAlternativeServices(test_server); 10127 http_server_properties->GetAlternativeServices(test_server);
10128 EXPECT_TRUE(alternative_service_vector.empty()); 10128 EXPECT_TRUE(alternative_service_vector.empty());
10129 10129
10130 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10130 EXPECT_THAT(callback.WaitForResult(), IsOk());
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
10198 10198
10199 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10199 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10200 HttpRequestInfo request; 10200 HttpRequestInfo request;
10201 request.method = "GET"; 10201 request.method = "GET";
10202 request.url = GURL(origin_url); 10202 request.url = GURL(origin_url);
10203 request.load_flags = 0; 10203 request.load_flags = 0;
10204 TestCompletionCallback callback; 10204 TestCompletionCallback callback;
10205 NetErrorDetails details; 10205 NetErrorDetails details;
10206 EXPECT_FALSE(details.quic_broken); 10206 EXPECT_FALSE(details.quic_broken);
10207 10207
10208 trans.Start(&request, callback.callback(), BoundNetLog()); 10208 trans.Start(&request, callback.callback(), NetLogWithSource());
10209 trans.PopulateNetErrorDetails(&details); 10209 trans.PopulateNetErrorDetails(&details);
10210 EXPECT_TRUE(details.quic_broken); 10210 EXPECT_TRUE(details.quic_broken);
10211 } 10211 }
10212 10212
10213 TEST_F(HttpNetworkTransactionTest, IdentifyQuicNotBroken) { 10213 TEST_F(HttpNetworkTransactionTest, IdentifyQuicNotBroken) {
10214 url::SchemeHostPort server("https", "origin.example.org", 443); 10214 url::SchemeHostPort server("https", "origin.example.org", 443);
10215 HostPortPair alternative1("alternative1.example.org", 443); 10215 HostPortPair alternative1("alternative1.example.org", 443);
10216 HostPortPair alternative2("alternative2.example.org", 443); 10216 HostPortPair alternative2("alternative2.example.org", 443);
10217 std::string origin_url = "https://origin.example.org:443"; 10217 std::string origin_url = "https://origin.example.org:443";
10218 std::string alternative_url1 = "https://alternative1.example.org:443"; 10218 std::string alternative_url1 = "https://alternative1.example.org:443";
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
10272 10272
10273 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10273 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10274 HttpRequestInfo request; 10274 HttpRequestInfo request;
10275 request.method = "GET"; 10275 request.method = "GET";
10276 request.url = GURL(origin_url); 10276 request.url = GURL(origin_url);
10277 request.load_flags = 0; 10277 request.load_flags = 0;
10278 TestCompletionCallback callback; 10278 TestCompletionCallback callback;
10279 NetErrorDetails details; 10279 NetErrorDetails details;
10280 EXPECT_FALSE(details.quic_broken); 10280 EXPECT_FALSE(details.quic_broken);
10281 10281
10282 trans.Start(&request, callback.callback(), BoundNetLog()); 10282 trans.Start(&request, callback.callback(), NetLogWithSource());
10283 trans.PopulateNetErrorDetails(&details); 10283 trans.PopulateNetErrorDetails(&details);
10284 EXPECT_FALSE(details.quic_broken); 10284 EXPECT_FALSE(details.quic_broken);
10285 } 10285 }
10286 10286
10287 TEST_F(HttpNetworkTransactionTest, MarkBrokenAlternateProtocolAndFallback) { 10287 TEST_F(HttpNetworkTransactionTest, MarkBrokenAlternateProtocolAndFallback) {
10288 HttpRequestInfo request; 10288 HttpRequestInfo request;
10289 request.method = "GET"; 10289 request.method = "GET";
10290 request.url = GURL("https://www.example.org/"); 10290 request.url = GURL("https://www.example.org/");
10291 request.load_flags = 0; 10291 request.load_flags = 0;
10292 10292
(...skipping 24 matching lines...) Expand all
10317 const AlternativeService alternative_service( 10317 const AlternativeService alternative_service(
10318 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org", 10318 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org",
10319 666); // Port is ignored by MockConnect anyway. 10319 666); // Port is ignored by MockConnect anyway.
10320 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10320 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10321 http_server_properties->SetAlternativeService(server, alternative_service, 10321 http_server_properties->SetAlternativeService(server, alternative_service,
10322 expiration); 10322 expiration);
10323 10323
10324 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10324 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10325 TestCompletionCallback callback; 10325 TestCompletionCallback callback;
10326 10326
10327 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 10327 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
10328 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10328 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10329 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10329 EXPECT_THAT(callback.WaitForResult(), IsOk());
10330 10330
10331 const HttpResponseInfo* response = trans.GetResponseInfo(); 10331 const HttpResponseInfo* response = trans.GetResponseInfo();
10332 ASSERT_TRUE(response); 10332 ASSERT_TRUE(response);
10333 ASSERT_TRUE(response->headers); 10333 ASSERT_TRUE(response->headers);
10334 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10334 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10335 10335
10336 std::string response_data; 10336 std::string response_data;
10337 ASSERT_THAT(ReadTransaction(&trans, &response_data), IsOk()); 10337 ASSERT_THAT(ReadTransaction(&trans, &response_data), IsOk());
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
10381 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org", 10381 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org",
10382 kUnrestrictedAlternatePort); 10382 kUnrestrictedAlternatePort);
10383 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10383 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10384 http_server_properties->SetAlternativeService( 10384 http_server_properties->SetAlternativeService(
10385 url::SchemeHostPort(restricted_port_request.url), alternative_service, 10385 url::SchemeHostPort(restricted_port_request.url), alternative_service,
10386 expiration); 10386 expiration);
10387 10387
10388 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10388 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10389 TestCompletionCallback callback; 10389 TestCompletionCallback callback;
10390 10390
10391 int rv = 10391 int rv = trans.Start(&restricted_port_request, callback.callback(),
10392 trans.Start(&restricted_port_request, callback.callback(), BoundNetLog()); 10392 NetLogWithSource());
10393 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10393 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10394 // Invalid change to unrestricted port should fail. 10394 // Invalid change to unrestricted port should fail.
10395 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_REFUSED)); 10395 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_REFUSED));
10396 } 10396 }
10397 10397
10398 // Ensure that we are allowed to redirect traffic via an alternate protocol to 10398 // Ensure that we are allowed to redirect traffic via an alternate protocol to
10399 // an unrestricted (port >= 1024) when the original traffic was on a restricted 10399 // an unrestricted (port >= 1024) when the original traffic was on a restricted
10400 // port (port < 1024) if we set |enable_user_alternate_protocol_ports|. 10400 // port (port < 1024) if we set |enable_user_alternate_protocol_ports|.
10401 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortRestrictedPermitted) { 10401 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortRestrictedPermitted) {
10402 session_deps_.enable_user_alternate_protocol_ports = true; 10402 session_deps_.enable_user_alternate_protocol_ports = true;
(...skipping 29 matching lines...) Expand all
10432 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org", 10432 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org",
10433 kUnrestrictedAlternatePort); 10433 kUnrestrictedAlternatePort);
10434 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10434 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10435 http_server_properties->SetAlternativeService( 10435 http_server_properties->SetAlternativeService(
10436 url::SchemeHostPort(restricted_port_request.url), alternative_service, 10436 url::SchemeHostPort(restricted_port_request.url), alternative_service,
10437 expiration); 10437 expiration);
10438 10438
10439 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10439 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10440 TestCompletionCallback callback; 10440 TestCompletionCallback callback;
10441 10441
10442 EXPECT_EQ(ERR_IO_PENDING, trans.Start(&restricted_port_request, 10442 EXPECT_EQ(ERR_IO_PENDING,
10443 callback.callback(), BoundNetLog())); 10443 trans.Start(&restricted_port_request, callback.callback(),
10444 NetLogWithSource()));
10444 // Change to unrestricted port should succeed. 10445 // Change to unrestricted port should succeed.
10445 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10446 EXPECT_THAT(callback.WaitForResult(), IsOk());
10446 } 10447 }
10447 10448
10448 // Ensure that we are not allowed to redirect traffic via an alternate protocol 10449 // Ensure that we are not allowed to redirect traffic via an alternate protocol
10449 // to an unrestricted (port >= 1024) when the original traffic was on a 10450 // to an unrestricted (port >= 1024) when the original traffic was on a
10450 // restricted port (port < 1024). Ensure that we can redirect in all other 10451 // restricted port (port < 1024). Ensure that we can redirect in all other
10451 // cases. 10452 // cases.
10452 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortRestrictedAllowed) { 10453 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortRestrictedAllowed) {
10453 HttpRequestInfo restricted_port_request; 10454 HttpRequestInfo restricted_port_request;
(...skipping 27 matching lines...) Expand all
10481 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org", 10482 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org",
10482 kRestrictedAlternatePort); 10483 kRestrictedAlternatePort);
10483 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10484 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10484 http_server_properties->SetAlternativeService( 10485 http_server_properties->SetAlternativeService(
10485 url::SchemeHostPort(restricted_port_request.url), alternative_service, 10486 url::SchemeHostPort(restricted_port_request.url), alternative_service,
10486 expiration); 10487 expiration);
10487 10488
10488 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10489 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10489 TestCompletionCallback callback; 10490 TestCompletionCallback callback;
10490 10491
10491 int rv = 10492 int rv = trans.Start(&restricted_port_request, callback.callback(),
10492 trans.Start(&restricted_port_request, callback.callback(), BoundNetLog()); 10493 NetLogWithSource());
10493 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10494 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10494 // Valid change to restricted port should pass. 10495 // Valid change to restricted port should pass.
10495 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10496 EXPECT_THAT(callback.WaitForResult(), IsOk());
10496 } 10497 }
10497 10498
10498 // Ensure that we are not allowed to redirect traffic via an alternate protocol 10499 // Ensure that we are not allowed to redirect traffic via an alternate protocol
10499 // to an unrestricted (port >= 1024) when the original traffic was on a 10500 // to an unrestricted (port >= 1024) when the original traffic was on a
10500 // restricted port (port < 1024). Ensure that we can redirect in all other 10501 // restricted port (port < 1024). Ensure that we can redirect in all other
10501 // cases. 10502 // cases.
10502 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortUnrestrictedAllowed1) { 10503 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortUnrestrictedAllowed1) {
(...skipping 29 matching lines...) Expand all
10532 kRestrictedAlternatePort); 10533 kRestrictedAlternatePort);
10533 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10534 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10534 http_server_properties->SetAlternativeService( 10535 http_server_properties->SetAlternativeService(
10535 url::SchemeHostPort(unrestricted_port_request.url), alternative_service, 10536 url::SchemeHostPort(unrestricted_port_request.url), alternative_service,
10536 expiration); 10537 expiration);
10537 10538
10538 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10539 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10539 TestCompletionCallback callback; 10540 TestCompletionCallback callback;
10540 10541
10541 int rv = trans.Start(&unrestricted_port_request, callback.callback(), 10542 int rv = trans.Start(&unrestricted_port_request, callback.callback(),
10542 BoundNetLog()); 10543 NetLogWithSource());
10543 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10544 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10544 // Valid change to restricted port should pass. 10545 // Valid change to restricted port should pass.
10545 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10546 EXPECT_THAT(callback.WaitForResult(), IsOk());
10546 } 10547 }
10547 10548
10548 // Ensure that we are not allowed to redirect traffic via an alternate protocol 10549 // Ensure that we are not allowed to redirect traffic via an alternate protocol
10549 // to an unrestricted (port >= 1024) when the original traffic was on a 10550 // to an unrestricted (port >= 1024) when the original traffic was on a
10550 // restricted port (port < 1024). Ensure that we can redirect in all other 10551 // restricted port (port < 1024). Ensure that we can redirect in all other
10551 // cases. 10552 // cases.
10552 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortUnrestrictedAllowed2) { 10553 TEST_F(HttpNetworkTransactionTest, AlternateProtocolPortUnrestrictedAllowed2) {
(...skipping 29 matching lines...) Expand all
10582 kUnrestrictedAlternatePort); 10583 kUnrestrictedAlternatePort);
10583 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10584 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10584 http_server_properties->SetAlternativeService( 10585 http_server_properties->SetAlternativeService(
10585 url::SchemeHostPort(unrestricted_port_request.url), alternative_service, 10586 url::SchemeHostPort(unrestricted_port_request.url), alternative_service,
10586 expiration); 10587 expiration);
10587 10588
10588 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10589 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10589 TestCompletionCallback callback; 10590 TestCompletionCallback callback;
10590 10591
10591 int rv = trans.Start(&unrestricted_port_request, callback.callback(), 10592 int rv = trans.Start(&unrestricted_port_request, callback.callback(),
10592 BoundNetLog()); 10593 NetLogWithSource());
10593 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10594 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10594 // Valid change to an unrestricted port should pass. 10595 // Valid change to an unrestricted port should pass.
10595 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10596 EXPECT_THAT(callback.WaitForResult(), IsOk());
10596 } 10597 }
10597 10598
10598 // Ensure that we are not allowed to redirect traffic via an alternate protocol 10599 // Ensure that we are not allowed to redirect traffic via an alternate protocol
10599 // to an unsafe port, and that we resume the second HttpStreamFactoryImpl::Job 10600 // to an unsafe port, and that we resume the second HttpStreamFactoryImpl::Job
10600 // once the alternate protocol request fails. 10601 // once the alternate protocol request fails.
10601 TEST_F(HttpNetworkTransactionTest, AlternateProtocolUnsafeBlocked) { 10602 TEST_F(HttpNetworkTransactionTest, AlternateProtocolUnsafeBlocked) {
10602 HttpRequestInfo request; 10603 HttpRequestInfo request;
(...skipping 20 matching lines...) Expand all
10623 AlternativeService alternative_service( 10624 AlternativeService alternative_service(
10624 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org", 10625 AlternateProtocolFromNextProto(kProtoHTTP2), "www.example.org",
10625 kUnsafePort); 10626 kUnsafePort);
10626 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 10627 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
10627 http_server_properties->SetAlternativeService( 10628 http_server_properties->SetAlternativeService(
10628 url::SchemeHostPort(request.url), alternative_service, expiration); 10629 url::SchemeHostPort(request.url), alternative_service, expiration);
10629 10630
10630 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 10631 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
10631 TestCompletionCallback callback; 10632 TestCompletionCallback callback;
10632 10633
10633 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 10634 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
10634 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10635 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10635 // The HTTP request should succeed. 10636 // The HTTP request should succeed.
10636 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10637 EXPECT_THAT(callback.WaitForResult(), IsOk());
10637 10638
10638 const HttpResponseInfo* response = trans.GetResponseInfo(); 10639 const HttpResponseInfo* response = trans.GetResponseInfo();
10639 ASSERT_TRUE(response); 10640 ASSERT_TRUE(response);
10640 ASSERT_TRUE(response->headers); 10641 ASSERT_TRUE(response->headers);
10641 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10642 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10642 10643
10643 std::string response_data; 10644 std::string response_data;
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
10694 never_finishing_connect); 10695 never_finishing_connect);
10695 session_deps_.socket_factory->AddSocketDataProvider( 10696 session_deps_.socket_factory->AddSocketDataProvider(
10696 &hanging_non_alternate_protocol_socket); 10697 &hanging_non_alternate_protocol_socket);
10697 10698
10698 TestCompletionCallback callback; 10699 TestCompletionCallback callback;
10699 10700
10700 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 10701 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
10701 std::unique_ptr<HttpNetworkTransaction> trans( 10702 std::unique_ptr<HttpNetworkTransaction> trans(
10702 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 10703 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
10703 10704
10704 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 10705 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
10705 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10706 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10706 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10707 EXPECT_THAT(callback.WaitForResult(), IsOk());
10707 10708
10708 const HttpResponseInfo* response = trans->GetResponseInfo(); 10709 const HttpResponseInfo* response = trans->GetResponseInfo();
10709 ASSERT_TRUE(response); 10710 ASSERT_TRUE(response);
10710 ASSERT_TRUE(response->headers); 10711 ASSERT_TRUE(response->headers);
10711 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10712 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10712 10713
10713 std::string response_data; 10714 std::string response_data;
10714 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 10715 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
10715 EXPECT_EQ("hello world", response_data); 10716 EXPECT_EQ("hello world", response_data);
10716 10717
10717 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 10718 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
10718 10719
10719 rv = trans->Start(&request, callback.callback(), BoundNetLog()); 10720 rv = trans->Start(&request, callback.callback(), NetLogWithSource());
10720 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10721 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10721 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10722 EXPECT_THAT(callback.WaitForResult(), IsOk());
10722 10723
10723 response = trans->GetResponseInfo(); 10724 response = trans->GetResponseInfo();
10724 ASSERT_TRUE(response); 10725 ASSERT_TRUE(response);
10725 ASSERT_TRUE(response->headers); 10726 ASSERT_TRUE(response->headers);
10726 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 10727 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
10727 EXPECT_TRUE(response->was_fetched_via_spdy); 10728 EXPECT_TRUE(response->was_fetched_via_spdy);
10728 EXPECT_TRUE(response->was_alpn_negotiated); 10729 EXPECT_TRUE(response->was_alpn_negotiated);
10729 10730
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
10797 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_http2); 10798 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_http2);
10798 10799
10799 StaticSocketDataProvider hanging_socket3(NULL, 0, NULL, 0); 10800 StaticSocketDataProvider hanging_socket3(NULL, 0, NULL, 0);
10800 hanging_socket3.set_connect_data(never_finishing_connect); 10801 hanging_socket3.set_connect_data(never_finishing_connect);
10801 session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket3); 10802 session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket3);
10802 10803
10803 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 10804 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
10804 TestCompletionCallback callback1; 10805 TestCompletionCallback callback1;
10805 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 10806 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
10806 10807
10807 int rv = trans1.Start(&request, callback1.callback(), BoundNetLog()); 10808 int rv = trans1.Start(&request, callback1.callback(), NetLogWithSource());
10808 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10809 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10809 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 10810 EXPECT_THAT(callback1.WaitForResult(), IsOk());
10810 10811
10811 const HttpResponseInfo* response = trans1.GetResponseInfo(); 10812 const HttpResponseInfo* response = trans1.GetResponseInfo();
10812 ASSERT_TRUE(response); 10813 ASSERT_TRUE(response);
10813 ASSERT_TRUE(response->headers); 10814 ASSERT_TRUE(response->headers);
10814 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10815 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10815 10816
10816 std::string response_data; 10817 std::string response_data;
10817 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk()); 10818 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk());
10818 EXPECT_EQ("hello world", response_data); 10819 EXPECT_EQ("hello world", response_data);
10819 10820
10820 TestCompletionCallback callback2; 10821 TestCompletionCallback callback2;
10821 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 10822 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
10822 rv = trans2.Start(&request, callback2.callback(), BoundNetLog()); 10823 rv = trans2.Start(&request, callback2.callback(), NetLogWithSource());
10823 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10824 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10824 10825
10825 TestCompletionCallback callback3; 10826 TestCompletionCallback callback3;
10826 HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get()); 10827 HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get());
10827 rv = trans3.Start(&request, callback3.callback(), BoundNetLog()); 10828 rv = trans3.Start(&request, callback3.callback(), NetLogWithSource());
10828 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10829 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10829 10830
10830 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 10831 EXPECT_THAT(callback2.WaitForResult(), IsOk());
10831 EXPECT_THAT(callback3.WaitForResult(), IsOk()); 10832 EXPECT_THAT(callback3.WaitForResult(), IsOk());
10832 10833
10833 response = trans2.GetResponseInfo(); 10834 response = trans2.GetResponseInfo();
10834 ASSERT_TRUE(response); 10835 ASSERT_TRUE(response);
10835 ASSERT_TRUE(response->headers); 10836 ASSERT_TRUE(response->headers);
10836 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 10837 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
10837 EXPECT_TRUE(response->was_fetched_via_spdy); 10838 EXPECT_TRUE(response->was_fetched_via_spdy);
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
10884 NULL, 0); 10885 NULL, 0);
10885 session_deps_.socket_factory->AddSocketDataProvider(&second_transaction); 10886 session_deps_.socket_factory->AddSocketDataProvider(&second_transaction);
10886 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 10887 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
10887 10888
10888 TestCompletionCallback callback; 10889 TestCompletionCallback callback;
10889 10890
10890 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 10891 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
10891 std::unique_ptr<HttpNetworkTransaction> trans( 10892 std::unique_ptr<HttpNetworkTransaction> trans(
10892 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 10893 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
10893 10894
10894 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 10895 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
10895 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10896 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10896 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10897 EXPECT_THAT(callback.WaitForResult(), IsOk());
10897 10898
10898 const HttpResponseInfo* response = trans->GetResponseInfo(); 10899 const HttpResponseInfo* response = trans->GetResponseInfo();
10899 ASSERT_TRUE(response); 10900 ASSERT_TRUE(response);
10900 ASSERT_TRUE(response->headers); 10901 ASSERT_TRUE(response->headers);
10901 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10902 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10902 10903
10903 std::string response_data; 10904 std::string response_data;
10904 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 10905 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
10905 EXPECT_EQ("hello world", response_data); 10906 EXPECT_EQ("hello world", response_data);
10906 10907
10907 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 10908 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
10908 10909
10909 rv = trans->Start(&request, callback.callback(), BoundNetLog()); 10910 rv = trans->Start(&request, callback.callback(), NetLogWithSource());
10910 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 10911 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
10911 EXPECT_THAT(callback.WaitForResult(), IsOk()); 10912 EXPECT_THAT(callback.WaitForResult(), IsOk());
10912 10913
10913 response = trans->GetResponseInfo(); 10914 response = trans->GetResponseInfo();
10914 ASSERT_TRUE(response); 10915 ASSERT_TRUE(response);
10915 ASSERT_TRUE(response->headers); 10916 ASSERT_TRUE(response->headers);
10916 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 10917 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
10917 EXPECT_FALSE(response->was_fetched_via_spdy); 10918 EXPECT_FALSE(response->was_fetched_via_spdy);
10918 EXPECT_FALSE(response->was_alpn_negotiated); 10919 EXPECT_FALSE(response->was_alpn_negotiated);
10919 10920
10920 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 10921 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
10921 EXPECT_EQ("hello world", response_data); 10922 EXPECT_EQ("hello world", response_data);
10922 } 10923 }
10923 10924
10924 class CapturingProxyResolver : public ProxyResolver { 10925 class CapturingProxyResolver : public ProxyResolver {
10925 public: 10926 public:
10926 CapturingProxyResolver() {} 10927 CapturingProxyResolver() {}
10927 ~CapturingProxyResolver() override {} 10928 ~CapturingProxyResolver() override {}
10928 10929
10929 int GetProxyForURL(const GURL& url, 10930 int GetProxyForURL(const GURL& url,
10930 ProxyInfo* results, 10931 ProxyInfo* results,
10931 const CompletionCallback& callback, 10932 const CompletionCallback& callback,
10932 RequestHandle* request, 10933 RequestHandle* request,
10933 const BoundNetLog& net_log) override { 10934 const NetLogWithSource& net_log) override {
10934 ProxyServer proxy_server(ProxyServer::SCHEME_HTTP, 10935 ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
10935 HostPortPair("myproxy", 80)); 10936 HostPortPair("myproxy", 80));
10936 results->UseProxyServer(proxy_server); 10937 results->UseProxyServer(proxy_server);
10937 resolved_.push_back(url); 10938 resolved_.push_back(url);
10938 return OK; 10939 return OK;
10939 } 10940 }
10940 10941
10941 void CancelRequest(RequestHandle request) override { NOTREACHED(); } 10942 void CancelRequest(RequestHandle request) override { NOTREACHED(); }
10942 10943
10943 LoadState GetLoadState(RequestHandle request) const override { 10944 LoadState GetLoadState(RequestHandle request) const override {
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after
11038 }; 11039 };
11039 11040
11040 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, 11041 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
11041 arraysize(spdy_writes)); 11042 arraysize(spdy_writes));
11042 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 11043 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
11043 11044
11044 TestCompletionCallback callback; 11045 TestCompletionCallback callback;
11045 11046
11046 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 11047 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
11047 11048
11048 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 11049 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
11049 EXPECT_THAT(callback.GetResult(rv), IsOk()); 11050 EXPECT_THAT(callback.GetResult(rv), IsOk());
11050 11051
11051 const HttpResponseInfo* response = trans.GetResponseInfo(); 11052 const HttpResponseInfo* response = trans.GetResponseInfo();
11052 ASSERT_TRUE(response); 11053 ASSERT_TRUE(response);
11053 ASSERT_TRUE(response->headers); 11054 ASSERT_TRUE(response->headers);
11054 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 11055 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
11055 EXPECT_TRUE(response->was_fetched_via_spdy); 11056 EXPECT_TRUE(response->was_fetched_via_spdy);
11056 EXPECT_TRUE(response->was_alpn_negotiated); 11057 EXPECT_TRUE(response->was_alpn_negotiated);
11057 11058
11058 std::string response_data; 11059 std::string response_data;
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after
11135 never_finishing_connect); 11136 never_finishing_connect);
11136 session_deps_.socket_factory->AddSocketDataProvider( 11137 session_deps_.socket_factory->AddSocketDataProvider(
11137 &hanging_non_alternate_protocol_socket); 11138 &hanging_non_alternate_protocol_socket);
11138 11139
11139 TestCompletionCallback callback; 11140 TestCompletionCallback callback;
11140 11141
11141 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 11142 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
11142 std::unique_ptr<HttpNetworkTransaction> trans( 11143 std::unique_ptr<HttpNetworkTransaction> trans(
11143 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 11144 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
11144 11145
11145 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 11146 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
11146 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11147 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11147 EXPECT_THAT(callback.WaitForResult(), IsOk()); 11148 EXPECT_THAT(callback.WaitForResult(), IsOk());
11148 11149
11149 const HttpResponseInfo* response = trans->GetResponseInfo(); 11150 const HttpResponseInfo* response = trans->GetResponseInfo();
11150 ASSERT_TRUE(response); 11151 ASSERT_TRUE(response);
11151 ASSERT_TRUE(response->headers); 11152 ASSERT_TRUE(response->headers);
11152 EXPECT_EQ("HTTP/0.9 200 OK", response->headers->GetStatusLine()); 11153 EXPECT_EQ("HTTP/0.9 200 OK", response->headers->GetStatusLine());
11153 EXPECT_FALSE(response->was_fetched_via_spdy); 11154 EXPECT_FALSE(response->was_fetched_via_spdy);
11154 EXPECT_TRUE(response->was_alpn_negotiated); 11155 EXPECT_TRUE(response->was_alpn_negotiated);
11155 11156
11156 std::string response_data; 11157 std::string response_data;
11157 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 11158 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
11158 EXPECT_EQ("hello world", response_data); 11159 EXPECT_EQ("hello world", response_data);
11159 11160
11160 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 11161 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
11161 11162
11162 rv = trans->Start(&request, callback.callback(), BoundNetLog()); 11163 rv = trans->Start(&request, callback.callback(), NetLogWithSource());
11163 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11164 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11164 EXPECT_THAT(callback.WaitForResult(), IsOk()); 11165 EXPECT_THAT(callback.WaitForResult(), IsOk());
11165 11166
11166 response = trans->GetResponseInfo(); 11167 response = trans->GetResponseInfo();
11167 ASSERT_TRUE(response); 11168 ASSERT_TRUE(response);
11168 ASSERT_TRUE(response->headers); 11169 ASSERT_TRUE(response->headers);
11169 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 11170 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
11170 EXPECT_TRUE(response->was_fetched_via_spdy); 11171 EXPECT_TRUE(response->was_fetched_via_spdy);
11171 EXPECT_TRUE(response->was_alpn_negotiated); 11172 EXPECT_TRUE(response->was_alpn_negotiated);
11172 11173
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
11227 arraysize(spdy_writes)); 11228 arraysize(spdy_writes));
11228 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 11229 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
11229 11230
11230 TestCompletionCallback callback; 11231 TestCompletionCallback callback;
11231 11232
11232 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 11233 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
11233 11234
11234 std::unique_ptr<HttpNetworkTransaction> trans( 11235 std::unique_ptr<HttpNetworkTransaction> trans(
11235 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 11236 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
11236 11237
11237 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 11238 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
11238 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11239 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11239 EXPECT_THAT(callback.WaitForResult(), IsOk()); 11240 EXPECT_THAT(callback.WaitForResult(), IsOk());
11240 11241
11241 const HttpResponseInfo* response = trans->GetResponseInfo(); 11242 const HttpResponseInfo* response = trans->GetResponseInfo();
11242 ASSERT_TRUE(response); 11243 ASSERT_TRUE(response);
11243 ASSERT_TRUE(response->headers); 11244 ASSERT_TRUE(response->headers);
11244 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 11245 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
11245 11246
11246 std::string response_data; 11247 std::string response_data;
11247 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 11248 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
11248 EXPECT_EQ("hello world", response_data); 11249 EXPECT_EQ("hello world", response_data);
11249 11250
11250 // Set up an initial SpdySession in the pool to reuse. 11251 // Set up an initial SpdySession in the pool to reuse.
11251 HostPortPair host_port_pair("www.example.org", 443); 11252 HostPortPair host_port_pair("www.example.org", 443);
11252 SpdySessionKey key(host_port_pair, ProxyServer::Direct(), 11253 SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
11253 PRIVACY_MODE_DISABLED); 11254 PRIVACY_MODE_DISABLED);
11254 base::WeakPtr<SpdySession> spdy_session = 11255 base::WeakPtr<SpdySession> spdy_session =
11255 CreateSecureSpdySession(session.get(), key, BoundNetLog()); 11256 CreateSecureSpdySession(session.get(), key, NetLogWithSource());
11256 11257
11257 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 11258 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
11258 11259
11259 rv = trans->Start(&request, callback.callback(), BoundNetLog()); 11260 rv = trans->Start(&request, callback.callback(), NetLogWithSource());
11260 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11261 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11261 EXPECT_THAT(callback.WaitForResult(), IsOk()); 11262 EXPECT_THAT(callback.WaitForResult(), IsOk());
11262 11263
11263 response = trans->GetResponseInfo(); 11264 response = trans->GetResponseInfo();
11264 ASSERT_TRUE(response); 11265 ASSERT_TRUE(response);
11265 ASSERT_TRUE(response->headers); 11266 ASSERT_TRUE(response->headers);
11266 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 11267 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
11267 EXPECT_TRUE(response->was_fetched_via_spdy); 11268 EXPECT_TRUE(response->was_fetched_via_spdy);
11268 EXPECT_TRUE(response->was_alpn_negotiated); 11269 EXPECT_TRUE(response->was_alpn_negotiated);
11269 11270
(...skipping 313 matching lines...) Expand 10 before | Expand all | Expand 10 after
11583 11584
11584 // Set up authentication handlers as necessary. 11585 // Set up authentication handlers as necessary.
11585 if (test_config.proxy_auth_timing != AUTH_NONE) { 11586 if (test_config.proxy_auth_timing != AUTH_NONE) {
11586 for (int n = 0; n < 2; n++) { 11587 for (int n = 0; n < 2; n++) {
11587 HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock()); 11588 HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
11588 std::string auth_challenge = "Mock realm=proxy"; 11589 std::string auth_challenge = "Mock realm=proxy";
11589 GURL origin(test_config.proxy_url); 11590 GURL origin(test_config.proxy_url);
11590 HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(), 11591 HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(),
11591 auth_challenge.end()); 11592 auth_challenge.end());
11592 auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_PROXY, 11593 auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_PROXY,
11593 empty_ssl_info, origin, BoundNetLog()); 11594 empty_ssl_info, origin,
11595 NetLogWithSource());
11594 auth_handler->SetGenerateExpectation( 11596 auth_handler->SetGenerateExpectation(
11595 test_config.proxy_auth_timing == AUTH_ASYNC, 11597 test_config.proxy_auth_timing == AUTH_ASYNC,
11596 test_config.proxy_auth_rv); 11598 test_config.proxy_auth_rv);
11597 auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY); 11599 auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
11598 } 11600 }
11599 } 11601 }
11600 if (test_config.server_auth_timing != AUTH_NONE) { 11602 if (test_config.server_auth_timing != AUTH_NONE) {
11601 HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock()); 11603 HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
11602 std::string auth_challenge = "Mock realm=server"; 11604 std::string auth_challenge = "Mock realm=server";
11603 GURL origin(test_config.server_url); 11605 GURL origin(test_config.server_url);
11604 HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(), 11606 HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(),
11605 auth_challenge.end()); 11607 auth_challenge.end());
11606 auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER, 11608 auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER,
11607 empty_ssl_info, origin, BoundNetLog()); 11609 empty_ssl_info, origin,
11610 NetLogWithSource());
11608 auth_handler->SetGenerateExpectation( 11611 auth_handler->SetGenerateExpectation(
11609 test_config.server_auth_timing == AUTH_ASYNC, 11612 test_config.server_auth_timing == AUTH_ASYNC,
11610 test_config.server_auth_rv); 11613 test_config.server_auth_rv);
11611 auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER); 11614 auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER);
11612 } 11615 }
11613 if (test_config.proxy_url) { 11616 if (test_config.proxy_url) {
11614 session_deps_.proxy_service = 11617 session_deps_.proxy_service =
11615 ProxyService::CreateFixed(test_config.proxy_url); 11618 ProxyService::CreateFixed(test_config.proxy_url);
11616 } else { 11619 } else {
11617 session_deps_.proxy_service = ProxyService::CreateDirect(); 11620 session_deps_.proxy_service = ProxyService::CreateDirect();
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
11667 // Transaction must be created after DataProviders, so it's destroyed before 11670 // Transaction must be created after DataProviders, so it's destroyed before
11668 // they are as well. 11671 // they are as well.
11669 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 11672 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
11670 11673
11671 for (int round = 0; round < test_config.num_auth_rounds; ++round) { 11674 for (int round = 0; round < test_config.num_auth_rounds; ++round) {
11672 const TestRound& read_write_round = test_config.rounds[round]; 11675 const TestRound& read_write_round = test_config.rounds[round];
11673 // Start or restart the transaction. 11676 // Start or restart the transaction.
11674 TestCompletionCallback callback; 11677 TestCompletionCallback callback;
11675 int rv; 11678 int rv;
11676 if (round == 0) { 11679 if (round == 0) {
11677 rv = trans.Start(&request, callback.callback(), BoundNetLog()); 11680 rv = trans.Start(&request, callback.callback(), NetLogWithSource());
11678 } else { 11681 } else {
11679 rv = trans.RestartWithAuth( 11682 rv = trans.RestartWithAuth(
11680 AuthCredentials(kFoo, kBar), callback.callback()); 11683 AuthCredentials(kFoo, kBar), callback.callback());
11681 } 11684 }
11682 if (rv == ERR_IO_PENDING) 11685 if (rv == ERR_IO_PENDING)
11683 rv = callback.WaitForResult(); 11686 rv = callback.WaitForResult();
11684 11687
11685 // Compare results with expected data. 11688 // Compare results with expected data.
11686 EXPECT_EQ(read_write_round.expected_rv, rv); 11689 EXPECT_EQ(read_write_round.expected_rv, rv);
11687 const HttpResponseInfo* response = trans.GetResponseInfo(); 11690 const HttpResponseInfo* response = trans.GetResponseInfo();
(...skipping 20 matching lines...) Expand all
11708 session_deps_.host_resolver->set_synchronous_mode(true); 11711 session_deps_.host_resolver->set_synchronous_mode(true);
11709 11712
11710 HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock()); 11713 HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
11711 auth_handler->set_connection_based(true); 11714 auth_handler->set_connection_based(true);
11712 std::string auth_challenge = "Mock realm=server"; 11715 std::string auth_challenge = "Mock realm=server";
11713 GURL origin("http://www.example.com"); 11716 GURL origin("http://www.example.com");
11714 HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(), 11717 HttpAuthChallengeTokenizer tokenizer(auth_challenge.begin(),
11715 auth_challenge.end()); 11718 auth_challenge.end());
11716 SSLInfo empty_ssl_info; 11719 SSLInfo empty_ssl_info;
11717 auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER, 11720 auth_handler->InitFromChallenge(&tokenizer, HttpAuth::AUTH_SERVER,
11718 empty_ssl_info, origin, BoundNetLog()); 11721 empty_ssl_info, origin, NetLogWithSource());
11719 auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER); 11722 auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_SERVER);
11720 11723
11721 int rv = OK; 11724 int rv = OK;
11722 const HttpResponseInfo* response = NULL; 11725 const HttpResponseInfo* response = NULL;
11723 HttpRequestInfo request; 11726 HttpRequestInfo request;
11724 request.method = "GET"; 11727 request.method = "GET";
11725 request.url = origin; 11728 request.url = origin;
11726 request.load_flags = 0; 11729 request.load_flags = 0;
11727 11730
11728 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 11731 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after
11791 kSuccess, 11794 kSuccess,
11792 }; 11795 };
11793 StaticSocketDataProvider data_provider(reads, arraysize(reads), 11796 StaticSocketDataProvider data_provider(reads, arraysize(reads),
11794 writes, arraysize(writes)); 11797 writes, arraysize(writes));
11795 session_deps_.socket_factory->AddSocketDataProvider(&data_provider); 11798 session_deps_.socket_factory->AddSocketDataProvider(&data_provider);
11796 11799
11797 const char kSocketGroup[] = "www.example.com:80"; 11800 const char kSocketGroup[] = "www.example.com:80";
11798 11801
11799 // First round of authentication. 11802 // First round of authentication.
11800 auth_handler->SetGenerateExpectation(false, OK); 11803 auth_handler->SetGenerateExpectation(false, OK);
11801 rv = trans.Start(&request, callback.callback(), BoundNetLog()); 11804 rv = trans.Start(&request, callback.callback(), NetLogWithSource());
11802 if (rv == ERR_IO_PENDING) 11805 if (rv == ERR_IO_PENDING)
11803 rv = callback.WaitForResult(); 11806 rv = callback.WaitForResult();
11804 EXPECT_THAT(rv, IsOk()); 11807 EXPECT_THAT(rv, IsOk());
11805 response = trans.GetResponseInfo(); 11808 response = trans.GetResponseInfo();
11806 ASSERT_TRUE(response); 11809 ASSERT_TRUE(response);
11807 EXPECT_TRUE(response->auth_challenge); 11810 EXPECT_TRUE(response->auth_challenge);
11808 EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup)); 11811 EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
11809 11812
11810 // In between rounds, another request comes in for the same domain. 11813 // In between rounds, another request comes in for the same domain.
11811 // It should not be able to grab the TCP socket that trans has already 11814 // It should not be able to grab the TCP socket that trans has already
11812 // claimed. 11815 // claimed.
11813 HttpNetworkTransaction trans_compete(DEFAULT_PRIORITY, session.get()); 11816 HttpNetworkTransaction trans_compete(DEFAULT_PRIORITY, session.get());
11814 TestCompletionCallback callback_compete; 11817 TestCompletionCallback callback_compete;
11815 rv = 11818 rv = trans_compete.Start(&request, callback_compete.callback(),
11816 trans_compete.Start(&request, callback_compete.callback(), BoundNetLog()); 11819 NetLogWithSource());
11817 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11820 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11818 // callback_compete.WaitForResult at this point would stall forever, 11821 // callback_compete.WaitForResult at this point would stall forever,
11819 // since the HttpNetworkTransaction does not release the request back to 11822 // since the HttpNetworkTransaction does not release the request back to
11820 // the pool until after authentication completes. 11823 // the pool until after authentication completes.
11821 11824
11822 // Second round of authentication. 11825 // Second round of authentication.
11823 auth_handler->SetGenerateExpectation(false, OK); 11826 auth_handler->SetGenerateExpectation(false, OK);
11824 rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBar), callback.callback()); 11827 rv = trans.RestartWithAuth(AuthCredentials(kFoo, kBar), callback.callback());
11825 if (rv == ERR_IO_PENDING) 11828 if (rv == ERR_IO_PENDING)
11826 rv = callback.WaitForResult(); 11829 rv = callback.WaitForResult();
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after
11910 11913
11911 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 11914 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
11912 data_writes, arraysize(data_writes)); 11915 data_writes, arraysize(data_writes));
11913 session_deps_.socket_factory->AddSocketDataProvider(&data); 11916 session_deps_.socket_factory->AddSocketDataProvider(&data);
11914 11917
11915 TestCompletionCallback callback; 11918 TestCompletionCallback callback;
11916 11919
11917 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 11920 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
11918 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 11921 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
11919 11922
11920 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 11923 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
11921 11924
11922 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11925 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11923 EXPECT_THAT(callback.WaitForResult(), IsOk()); 11926 EXPECT_THAT(callback.WaitForResult(), IsOk());
11924 11927
11925 const HttpResponseInfo* response = trans.GetResponseInfo(); 11928 const HttpResponseInfo* response = trans.GetResponseInfo();
11926 ASSERT_TRUE(response); 11929 ASSERT_TRUE(response);
11927 ASSERT_TRUE(response->headers); 11930 ASSERT_TRUE(response->headers);
11928 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 11931 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
11929 11932
11930 std::string response_data; 11933 std::string response_data;
(...skipping 27 matching lines...) Expand all
11958 11961
11959 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, 11962 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes,
11960 arraysize(spdy_writes)); 11963 arraysize(spdy_writes));
11961 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 11964 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
11962 11965
11963 TestCompletionCallback callback; 11966 TestCompletionCallback callback;
11964 11967
11965 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 11968 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
11966 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 11969 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
11967 11970
11968 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 11971 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
11969 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 11972 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
11970 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED)); 11973 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
11971 } 11974 }
11972 11975
11973 // A subclass of HttpAuthHandlerMock that records the request URL when 11976 // A subclass of HttpAuthHandlerMock that records the request URL when
11974 // it gets it. This is needed since the auth handler may get destroyed 11977 // it gets it. This is needed since the auth handler may get destroyed
11975 // before we get a chance to query it. 11978 // before we get a chance to query it.
11976 class UrlRecordingHttpAuthHandlerMock : public HttpAuthHandlerMock { 11979 class UrlRecordingHttpAuthHandlerMock : public HttpAuthHandlerMock {
11977 public: 11980 public:
11978 explicit UrlRecordingHttpAuthHandlerMock(GURL* url) : url_(url) {} 11981 explicit UrlRecordingHttpAuthHandlerMock(GURL* url) : url_(url) {}
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after
12056 12059
12057 { 12060 {
12058 HttpRequestInfo request; 12061 HttpRequestInfo request;
12059 request.method = "GET"; 12062 request.method = "GET";
12060 request.url = GURL("http://www.example.org/"); 12063 request.url = GURL("http://www.example.org/");
12061 request.load_flags = 0; 12064 request.load_flags = 0;
12062 12065
12063 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 12066 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
12064 TestCompletionCallback callback; 12067 TestCompletionCallback callback;
12065 12068
12066 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 12069 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
12067 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12070 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12068 callback.WaitForResult(); 12071 callback.WaitForResult();
12069 12072
12070 const HttpResponseInfo* response = trans.GetResponseInfo(); 12073 const HttpResponseInfo* response = trans.GetResponseInfo();
12071 ASSERT_TRUE(response); 12074 ASSERT_TRUE(response);
12072 EXPECT_TRUE(response->headers); 12075 EXPECT_TRUE(response->headers);
12073 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 12076 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
12074 12077
12075 // The transaction and HttpRequestInfo are deleted. 12078 // The transaction and HttpRequestInfo are deleted.
12076 } 12079 }
(...skipping 300 matching lines...) Expand 10 before | Expand all | Expand 10 after
12377 ssl.next_proto = kProtoHTTP2; 12380 ssl.next_proto = kProtoHTTP2;
12378 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 12381 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
12379 12382
12380 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12383 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12381 12384
12382 // Set up an initial SpdySession in the pool to reuse. 12385 // Set up an initial SpdySession in the pool to reuse.
12383 HostPortPair host_port_pair("www.example.org", 443); 12386 HostPortPair host_port_pair("www.example.org", 443);
12384 SpdySessionKey key(host_port_pair, ProxyServer::Direct(), 12387 SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
12385 PRIVACY_MODE_DISABLED); 12388 PRIVACY_MODE_DISABLED);
12386 base::WeakPtr<SpdySession> spdy_session = 12389 base::WeakPtr<SpdySession> spdy_session =
12387 CreateInsecureSpdySession(session.get(), key, BoundNetLog()); 12390 CreateInsecureSpdySession(session.get(), key, NetLogWithSource());
12388 12391
12389 HttpRequestInfo request; 12392 HttpRequestInfo request;
12390 request.method = "GET"; 12393 request.method = "GET";
12391 request.url = GURL("https://www.example.org/"); 12394 request.url = GURL("https://www.example.org/");
12392 request.load_flags = 0; 12395 request.load_flags = 0;
12393 12396
12394 // This is the important line that marks this as a preconnect. 12397 // This is the important line that marks this as a preconnect.
12395 request.motivation = HttpRequestInfo::PRECONNECT_MOTIVATED; 12398 request.motivation = HttpRequestInfo::PRECONNECT_MOTIVATED;
12396 12399
12397 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 12400 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
12398 12401
12399 TestCompletionCallback callback; 12402 TestCompletionCallback callback;
12400 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 12403 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
12401 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12404 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12402 EXPECT_THAT(callback.WaitForResult(), IsOk()); 12405 EXPECT_THAT(callback.WaitForResult(), IsOk());
12403 } 12406 }
12404 12407
12405 // Given a net error, cause that error to be returned from the first Write() 12408 // Given a net error, cause that error to be returned from the first Write()
12406 // call and verify that the HttpNetworkTransaction fails with that error. 12409 // call and verify that the HttpNetworkTransaction fails with that error.
12407 void HttpNetworkTransactionTest::CheckErrorIsPassedBack( 12410 void HttpNetworkTransactionTest::CheckErrorIsPassedBack(
12408 int error, IoMode mode) { 12411 int error, IoMode mode) {
12409 HttpRequestInfo request_info; 12412 HttpRequestInfo request_info;
12410 request_info.url = GURL("https://www.example.com/"); 12413 request_info.url = GURL("https://www.example.com/");
12411 request_info.method = "GET"; 12414 request_info.method = "GET";
12412 request_info.load_flags = LOAD_NORMAL; 12415 request_info.load_flags = LOAD_NORMAL;
12413 12416
12414 SSLSocketDataProvider ssl_data(mode, OK); 12417 SSLSocketDataProvider ssl_data(mode, OK);
12415 MockWrite data_writes[] = { 12418 MockWrite data_writes[] = {
12416 MockWrite(mode, error), 12419 MockWrite(mode, error),
12417 }; 12420 };
12418 StaticSocketDataProvider data(NULL, 0, data_writes, arraysize(data_writes)); 12421 StaticSocketDataProvider data(NULL, 0, data_writes, arraysize(data_writes));
12419 session_deps_.socket_factory->AddSocketDataProvider(&data); 12422 session_deps_.socket_factory->AddSocketDataProvider(&data);
12420 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data); 12423 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data);
12421 12424
12422 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12425 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12423 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 12426 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
12424 12427
12425 TestCompletionCallback callback; 12428 TestCompletionCallback callback;
12426 int rv = trans.Start(&request_info, callback.callback(), BoundNetLog()); 12429 int rv = trans.Start(&request_info, callback.callback(), NetLogWithSource());
12427 if (rv == ERR_IO_PENDING) 12430 if (rv == ERR_IO_PENDING)
12428 rv = callback.WaitForResult(); 12431 rv = callback.WaitForResult();
12429 ASSERT_EQ(error, rv); 12432 ASSERT_EQ(error, rv);
12430 } 12433 }
12431 12434
12432 TEST_F(HttpNetworkTransactionTest, SSLWriteCertError) { 12435 TEST_F(HttpNetworkTransactionTest, SSLWriteCertError) {
12433 // Just check a grab bag of cert errors. 12436 // Just check a grab bag of cert errors.
12434 static const int kErrors[] = { 12437 static const int kErrors[] = {
12435 ERR_CERT_COMMON_NAME_INVALID, 12438 ERR_CERT_COMMON_NAME_INVALID,
12436 ERR_CERT_AUTHORITY_INVALID, 12439 ERR_CERT_AUTHORITY_INVALID,
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after
12502 ssl_data4.cert_request_info = cert_request.get(); 12505 ssl_data4.cert_request_info = cert_request.get();
12503 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data4); 12506 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data4);
12504 StaticSocketDataProvider data4(NULL, 0, NULL, 0); 12507 StaticSocketDataProvider data4(NULL, 0, NULL, 0);
12505 session_deps_.socket_factory->AddSocketDataProvider(&data4); 12508 session_deps_.socket_factory->AddSocketDataProvider(&data4);
12506 12509
12507 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12510 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12508 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 12511 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
12509 12512
12510 // Begin the SSL handshake with the peer. This consumes ssl_data1. 12513 // Begin the SSL handshake with the peer. This consumes ssl_data1.
12511 TestCompletionCallback callback; 12514 TestCompletionCallback callback;
12512 int rv = trans.Start(&request_info, callback.callback(), BoundNetLog()); 12515 int rv = trans.Start(&request_info, callback.callback(), NetLogWithSource());
12513 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 12516 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
12514 12517
12515 // Complete the SSL handshake, which should abort due to requiring a 12518 // Complete the SSL handshake, which should abort due to requiring a
12516 // client certificate. 12519 // client certificate.
12517 rv = callback.WaitForResult(); 12520 rv = callback.WaitForResult();
12518 ASSERT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED)); 12521 ASSERT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
12519 12522
12520 // Indicate that no certificate should be supplied. From the perspective 12523 // Indicate that no certificate should be supplied. From the perspective
12521 // of SSLClientCertCache, NULL is just as meaningful as a real 12524 // of SSLClientCertCache, NULL is just as meaningful as a real
12522 // certificate, so this is the same as supply a 12525 // certificate, so this is the same as supply a
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after
12618 ssl_data5.cert_request_info = cert_request.get(); 12621 ssl_data5.cert_request_info = cert_request.get();
12619 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data5); 12622 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data5);
12620 StaticSocketDataProvider data5(data2_reads, arraysize(data2_reads), NULL, 0); 12623 StaticSocketDataProvider data5(data2_reads, arraysize(data2_reads), NULL, 0);
12621 session_deps_.socket_factory->AddSocketDataProvider(&data5); 12624 session_deps_.socket_factory->AddSocketDataProvider(&data5);
12622 12625
12623 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12626 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12624 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 12627 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
12625 12628
12626 // Begin the initial SSL handshake. 12629 // Begin the initial SSL handshake.
12627 TestCompletionCallback callback; 12630 TestCompletionCallback callback;
12628 int rv = trans.Start(&request_info, callback.callback(), BoundNetLog()); 12631 int rv = trans.Start(&request_info, callback.callback(), NetLogWithSource());
12629 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 12632 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
12630 12633
12631 // Complete the SSL handshake, which should abort due to requiring a 12634 // Complete the SSL handshake, which should abort due to requiring a
12632 // client certificate. 12635 // client certificate.
12633 rv = callback.WaitForResult(); 12636 rv = callback.WaitForResult();
12634 ASSERT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED)); 12637 ASSERT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
12635 12638
12636 // Indicate that no certificate should be supplied. From the perspective 12639 // Indicate that no certificate should be supplied. From the perspective
12637 // of SSLClientCertCache, NULL is just as meaningful as a real 12640 // of SSLClientCertCache, NULL is just as meaningful as a real
12638 // certificate, so this is the same as supply a 12641 // certificate, so this is the same as supply a
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
12710 requests[1].method = "GET"; 12713 requests[1].method = "GET";
12711 requests[1].load_flags = LOAD_NORMAL; 12714 requests[1].load_flags = LOAD_NORMAL;
12712 12715
12713 for (size_t i = 0; i < arraysize(requests); ++i) { 12716 for (size_t i = 0; i < arraysize(requests); ++i) {
12714 session_deps_.socket_factory->ResetNextMockIndexes(); 12717 session_deps_.socket_factory->ResetNextMockIndexes();
12715 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12718 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12716 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 12719 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
12717 12720
12718 // Begin the SSL handshake with the proxy. 12721 // Begin the SSL handshake with the proxy.
12719 TestCompletionCallback callback; 12722 TestCompletionCallback callback;
12720 int rv = trans.Start(&requests[i], callback.callback(), BoundNetLog()); 12723 int rv = trans.Start(&requests[i], callback.callback(), NetLogWithSource());
12721 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 12724 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
12722 12725
12723 // Complete the SSL handshake, which should abort due to requiring a 12726 // Complete the SSL handshake, which should abort due to requiring a
12724 // client certificate. 12727 // client certificate.
12725 rv = callback.WaitForResult(); 12728 rv = callback.WaitForResult();
12726 ASSERT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED)); 12729 ASSERT_THAT(rv, IsError(ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
12727 12730
12728 // Indicate that no certificate should be supplied. From the perspective 12731 // Indicate that no certificate should be supplied. From the perspective
12729 // of SSLClientCertCache, NULL is just as meaningful as a real 12732 // of SSLClientCertCache, NULL is just as meaningful as a real
12730 // certificate, so this is the same as supply a 12733 // certificate, so this is the same as supply a
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
12798 spdy_writes, arraysize(spdy_writes)); 12801 spdy_writes, arraysize(spdy_writes));
12799 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 12802 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
12800 12803
12801 TestCompletionCallback callback; 12804 TestCompletionCallback callback;
12802 HttpRequestInfo request1; 12805 HttpRequestInfo request1;
12803 request1.method = "GET"; 12806 request1.method = "GET";
12804 request1.url = GURL("https://www.example.org/"); 12807 request1.url = GURL("https://www.example.org/");
12805 request1.load_flags = 0; 12808 request1.load_flags = 0;
12806 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 12809 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
12807 12810
12808 int rv = trans1.Start(&request1, callback.callback(), BoundNetLog()); 12811 int rv = trans1.Start(&request1, callback.callback(), NetLogWithSource());
12809 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12812 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12810 EXPECT_THAT(callback.WaitForResult(), IsOk()); 12813 EXPECT_THAT(callback.WaitForResult(), IsOk());
12811 12814
12812 const HttpResponseInfo* response = trans1.GetResponseInfo(); 12815 const HttpResponseInfo* response = trans1.GetResponseInfo();
12813 ASSERT_TRUE(response); 12816 ASSERT_TRUE(response);
12814 ASSERT_TRUE(response->headers); 12817 ASSERT_TRUE(response->headers);
12815 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 12818 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
12816 12819
12817 std::string response_data; 12820 std::string response_data;
12818 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk()); 12821 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk());
12819 EXPECT_EQ("hello!", response_data); 12822 EXPECT_EQ("hello!", response_data);
12820 12823
12821 // Preload www.gmail.com into HostCache. 12824 // Preload www.gmail.com into HostCache.
12822 HostPortPair host_port("www.gmail.com", 443); 12825 HostPortPair host_port("www.gmail.com", 443);
12823 HostResolver::RequestInfo resolve_info(host_port); 12826 HostResolver::RequestInfo resolve_info(host_port);
12824 AddressList ignored; 12827 AddressList ignored;
12825 std::unique_ptr<HostResolver::Request> request; 12828 std::unique_ptr<HostResolver::Request> request;
12826 rv = session_deps_.host_resolver->Resolve(resolve_info, DEFAULT_PRIORITY, 12829 rv = session_deps_.host_resolver->Resolve(resolve_info, DEFAULT_PRIORITY,
12827 &ignored, callback.callback(), 12830 &ignored, callback.callback(),
12828 &request, BoundNetLog()); 12831 &request, NetLogWithSource());
12829 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12832 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12830 rv = callback.WaitForResult(); 12833 rv = callback.WaitForResult();
12831 EXPECT_THAT(rv, IsOk()); 12834 EXPECT_THAT(rv, IsOk());
12832 12835
12833 HttpRequestInfo request2; 12836 HttpRequestInfo request2;
12834 request2.method = "GET"; 12837 request2.method = "GET";
12835 request2.url = GURL("https://www.gmail.com/"); 12838 request2.url = GURL("https://www.gmail.com/");
12836 request2.load_flags = 0; 12839 request2.load_flags = 0;
12837 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 12840 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
12838 12841
12839 rv = trans2.Start(&request2, callback.callback(), BoundNetLog()); 12842 rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
12840 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12843 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12841 EXPECT_THAT(callback.WaitForResult(), IsOk()); 12844 EXPECT_THAT(callback.WaitForResult(), IsOk());
12842 12845
12843 response = trans2.GetResponseInfo(); 12846 response = trans2.GetResponseInfo();
12844 ASSERT_TRUE(response); 12847 ASSERT_TRUE(response);
12845 ASSERT_TRUE(response->headers); 12848 ASSERT_TRUE(response->headers);
12846 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 12849 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
12847 EXPECT_TRUE(response->was_fetched_via_spdy); 12850 EXPECT_TRUE(response->was_fetched_via_spdy);
12848 EXPECT_TRUE(response->was_alpn_negotiated); 12851 EXPECT_TRUE(response->was_alpn_negotiated);
12849 ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk()); 12852 ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk());
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
12887 spdy_writes, arraysize(spdy_writes)); 12890 spdy_writes, arraysize(spdy_writes));
12888 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 12891 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
12889 12892
12890 TestCompletionCallback callback; 12893 TestCompletionCallback callback;
12891 HttpRequestInfo request1; 12894 HttpRequestInfo request1;
12892 request1.method = "GET"; 12895 request1.method = "GET";
12893 request1.url = GURL("https://www.example.org/"); 12896 request1.url = GURL("https://www.example.org/");
12894 request1.load_flags = 0; 12897 request1.load_flags = 0;
12895 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 12898 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
12896 12899
12897 int rv = trans1.Start(&request1, callback.callback(), BoundNetLog()); 12900 int rv = trans1.Start(&request1, callback.callback(), NetLogWithSource());
12898 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12901 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12899 EXPECT_THAT(callback.WaitForResult(), IsOk()); 12902 EXPECT_THAT(callback.WaitForResult(), IsOk());
12900 12903
12901 const HttpResponseInfo* response = trans1.GetResponseInfo(); 12904 const HttpResponseInfo* response = trans1.GetResponseInfo();
12902 ASSERT_TRUE(response); 12905 ASSERT_TRUE(response);
12903 ASSERT_TRUE(response->headers); 12906 ASSERT_TRUE(response->headers);
12904 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 12907 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
12905 12908
12906 std::string response_data; 12909 std::string response_data;
12907 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk()); 12910 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk());
12908 EXPECT_EQ("hello!", response_data); 12911 EXPECT_EQ("hello!", response_data);
12909 12912
12910 HttpRequestInfo request2; 12913 HttpRequestInfo request2;
12911 request2.method = "GET"; 12914 request2.method = "GET";
12912 request2.url = GURL("https://www.gmail.com/"); 12915 request2.url = GURL("https://www.gmail.com/");
12913 request2.load_flags = 0; 12916 request2.load_flags = 0;
12914 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 12917 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
12915 12918
12916 rv = trans2.Start(&request2, callback.callback(), BoundNetLog()); 12919 rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
12917 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 12920 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
12918 EXPECT_THAT(callback.WaitForResult(), IsOk()); 12921 EXPECT_THAT(callback.WaitForResult(), IsOk());
12919 12922
12920 response = trans2.GetResponseInfo(); 12923 response = trans2.GetResponseInfo();
12921 ASSERT_TRUE(response); 12924 ASSERT_TRUE(response);
12922 ASSERT_TRUE(response->headers); 12925 ASSERT_TRUE(response->headers);
12923 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 12926 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
12924 EXPECT_TRUE(response->was_fetched_via_spdy); 12927 EXPECT_TRUE(response->was_fetched_via_spdy);
12925 EXPECT_TRUE(response->was_alpn_negotiated); 12928 EXPECT_TRUE(response->was_alpn_negotiated);
12926 ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk()); 12929 ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk());
12927 EXPECT_EQ("hello!", response_data); 12930 EXPECT_EQ("hello!", response_data);
12928 } 12931 }
12929 12932
12930 class OneTimeCachingHostResolver : public HostResolver { 12933 class OneTimeCachingHostResolver : public HostResolver {
12931 public: 12934 public:
12932 explicit OneTimeCachingHostResolver(const HostPortPair& host_port) 12935 explicit OneTimeCachingHostResolver(const HostPortPair& host_port)
12933 : host_port_(host_port) {} 12936 : host_port_(host_port) {}
12934 ~OneTimeCachingHostResolver() override {} 12937 ~OneTimeCachingHostResolver() override {}
12935 12938
12936 RuleBasedHostResolverProc* rules() { return host_resolver_.rules(); } 12939 RuleBasedHostResolverProc* rules() { return host_resolver_.rules(); }
12937 12940
12938 // HostResolver methods: 12941 // HostResolver methods:
12939 int Resolve(const RequestInfo& info, 12942 int Resolve(const RequestInfo& info,
12940 RequestPriority priority, 12943 RequestPriority priority,
12941 AddressList* addresses, 12944 AddressList* addresses,
12942 const CompletionCallback& callback, 12945 const CompletionCallback& callback,
12943 std::unique_ptr<Request>* out_req, 12946 std::unique_ptr<Request>* out_req,
12944 const BoundNetLog& net_log) override { 12947 const NetLogWithSource& net_log) override {
12945 return host_resolver_.Resolve( 12948 return host_resolver_.Resolve(
12946 info, priority, addresses, callback, out_req, net_log); 12949 info, priority, addresses, callback, out_req, net_log);
12947 } 12950 }
12948 12951
12949 int ResolveFromCache(const RequestInfo& info, 12952 int ResolveFromCache(const RequestInfo& info,
12950 AddressList* addresses, 12953 AddressList* addresses,
12951 const BoundNetLog& net_log) override { 12954 const NetLogWithSource& net_log) override {
12952 int rv = host_resolver_.ResolveFromCache(info, addresses, net_log); 12955 int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
12953 if (rv == OK && info.host_port_pair().Equals(host_port_)) 12956 if (rv == OK && info.host_port_pair().Equals(host_port_))
12954 host_resolver_.GetHostCache()->clear(); 12957 host_resolver_.GetHostCache()->clear();
12955 return rv; 12958 return rv;
12956 } 12959 }
12957 12960
12958 MockCachingHostResolver* GetMockHostResolver() { 12961 MockCachingHostResolver* GetMockHostResolver() {
12959 return &host_resolver_; 12962 return &host_resolver_;
12960 } 12963 }
12961 12964
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
13005 spdy_writes, arraysize(spdy_writes)); 13008 spdy_writes, arraysize(spdy_writes));
13006 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); 13009 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
13007 13010
13008 TestCompletionCallback callback; 13011 TestCompletionCallback callback;
13009 HttpRequestInfo request1; 13012 HttpRequestInfo request1;
13010 request1.method = "GET"; 13013 request1.method = "GET";
13011 request1.url = GURL("https://www.example.org/"); 13014 request1.url = GURL("https://www.example.org/");
13012 request1.load_flags = 0; 13015 request1.load_flags = 0;
13013 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 13016 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
13014 13017
13015 int rv = trans1.Start(&request1, callback.callback(), BoundNetLog()); 13018 int rv = trans1.Start(&request1, callback.callback(), NetLogWithSource());
13016 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13019 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13017 EXPECT_THAT(callback.WaitForResult(), IsOk()); 13020 EXPECT_THAT(callback.WaitForResult(), IsOk());
13018 13021
13019 const HttpResponseInfo* response = trans1.GetResponseInfo(); 13022 const HttpResponseInfo* response = trans1.GetResponseInfo();
13020 ASSERT_TRUE(response); 13023 ASSERT_TRUE(response);
13021 ASSERT_TRUE(response->headers); 13024 ASSERT_TRUE(response->headers);
13022 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 13025 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
13023 13026
13024 std::string response_data; 13027 std::string response_data;
13025 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk()); 13028 ASSERT_THAT(ReadTransaction(&trans1, &response_data), IsOk());
13026 EXPECT_EQ("hello!", response_data); 13029 EXPECT_EQ("hello!", response_data);
13027 13030
13028 // Preload cache entries into HostCache. 13031 // Preload cache entries into HostCache.
13029 HostResolver::RequestInfo resolve_info(HostPortPair("www.gmail.com", 443)); 13032 HostResolver::RequestInfo resolve_info(HostPortPair("www.gmail.com", 443));
13030 AddressList ignored; 13033 AddressList ignored;
13031 std::unique_ptr<HostResolver::Request> request; 13034 std::unique_ptr<HostResolver::Request> request;
13032 rv = host_resolver.Resolve(resolve_info, DEFAULT_PRIORITY, &ignored, 13035 rv = host_resolver.Resolve(resolve_info, DEFAULT_PRIORITY, &ignored,
13033 callback.callback(), &request, BoundNetLog()); 13036 callback.callback(), &request, NetLogWithSource());
13034 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13037 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13035 rv = callback.WaitForResult(); 13038 rv = callback.WaitForResult();
13036 EXPECT_THAT(rv, IsOk()); 13039 EXPECT_THAT(rv, IsOk());
13037 13040
13038 HttpRequestInfo request2; 13041 HttpRequestInfo request2;
13039 request2.method = "GET"; 13042 request2.method = "GET";
13040 request2.url = GURL("https://www.gmail.com/"); 13043 request2.url = GURL("https://www.gmail.com/");
13041 request2.load_flags = 0; 13044 request2.load_flags = 0;
13042 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 13045 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
13043 13046
13044 rv = trans2.Start(&request2, callback.callback(), BoundNetLog()); 13047 rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
13045 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13048 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13046 EXPECT_THAT(callback.WaitForResult(), IsOk()); 13049 EXPECT_THAT(callback.WaitForResult(), IsOk());
13047 13050
13048 response = trans2.GetResponseInfo(); 13051 response = trans2.GetResponseInfo();
13049 ASSERT_TRUE(response); 13052 ASSERT_TRUE(response);
13050 ASSERT_TRUE(response->headers); 13053 ASSERT_TRUE(response->headers);
13051 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 13054 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
13052 EXPECT_TRUE(response->was_fetched_via_spdy); 13055 EXPECT_TRUE(response->was_fetched_via_spdy);
13053 EXPECT_TRUE(response->was_alpn_negotiated); 13056 EXPECT_TRUE(response->was_alpn_negotiated);
13054 ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk()); 13057 ASSERT_THAT(ReadTransaction(&trans2, &response_data), IsOk());
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
13103 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13106 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
13104 13107
13105 // Start the first transaction to set up the SpdySession 13108 // Start the first transaction to set up the SpdySession
13106 HttpRequestInfo request1; 13109 HttpRequestInfo request1;
13107 request1.method = "GET"; 13110 request1.method = "GET";
13108 request1.url = GURL(https_url); 13111 request1.url = GURL(https_url);
13109 request1.load_flags = 0; 13112 request1.load_flags = 0;
13110 HttpNetworkTransaction trans1(LOWEST, session.get()); 13113 HttpNetworkTransaction trans1(LOWEST, session.get());
13111 TestCompletionCallback callback1; 13114 TestCompletionCallback callback1;
13112 EXPECT_EQ(ERR_IO_PENDING, 13115 EXPECT_EQ(ERR_IO_PENDING,
13113 trans1.Start(&request1, callback1.callback(), BoundNetLog())); 13116 trans1.Start(&request1, callback1.callback(), NetLogWithSource()));
13114 base::RunLoop().RunUntilIdle(); 13117 base::RunLoop().RunUntilIdle();
13115 13118
13116 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 13119 EXPECT_THAT(callback1.WaitForResult(), IsOk());
13117 EXPECT_TRUE(trans1.GetResponseInfo()->was_fetched_via_spdy); 13120 EXPECT_TRUE(trans1.GetResponseInfo()->was_fetched_via_spdy);
13118 13121
13119 // Now, start the HTTP request 13122 // Now, start the HTTP request
13120 HttpRequestInfo request2; 13123 HttpRequestInfo request2;
13121 request2.method = "GET"; 13124 request2.method = "GET";
13122 request2.url = GURL(http_url); 13125 request2.url = GURL(http_url);
13123 request2.load_flags = 0; 13126 request2.load_flags = 0;
13124 HttpNetworkTransaction trans2(MEDIUM, session.get()); 13127 HttpNetworkTransaction trans2(MEDIUM, session.get());
13125 TestCompletionCallback callback2; 13128 TestCompletionCallback callback2;
13126 EXPECT_EQ(ERR_IO_PENDING, 13129 EXPECT_EQ(ERR_IO_PENDING,
13127 trans2.Start(&request2, callback2.callback(), BoundNetLog())); 13130 trans2.Start(&request2, callback2.callback(), NetLogWithSource()));
13128 base::RunLoop().RunUntilIdle(); 13131 base::RunLoop().RunUntilIdle();
13129 13132
13130 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 13133 EXPECT_THAT(callback2.WaitForResult(), IsOk());
13131 EXPECT_FALSE(trans2.GetResponseInfo()->was_fetched_via_spdy); 13134 EXPECT_FALSE(trans2.GetResponseInfo()->was_fetched_via_spdy);
13132 } 13135 }
13133 13136
13134 // Alternative service requires HTTP/2 (or SPDY), but HTTP/1.1 is negotiated 13137 // Alternative service requires HTTP/2 (or SPDY), but HTTP/1.1 is negotiated
13135 // with the alternative server. That connection should not be used. 13138 // with the alternative server. That connection should not be used.
13136 TEST_F(HttpNetworkTransactionTest, AlternativeServiceNotOnHttp11) { 13139 TEST_F(HttpNetworkTransactionTest, AlternativeServiceNotOnHttp11) {
13137 url::SchemeHostPort server("https", "www.example.org", 443); 13140 url::SchemeHostPort server("https", "www.example.org", 443);
(...skipping 28 matching lines...) Expand all
13166 13169
13167 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 13170 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
13168 HttpRequestInfo request; 13171 HttpRequestInfo request;
13169 request.method = "GET"; 13172 request.method = "GET";
13170 request.url = GURL("https://www.example.org:443"); 13173 request.url = GURL("https://www.example.org:443");
13171 request.load_flags = 0; 13174 request.load_flags = 0;
13172 TestCompletionCallback callback; 13175 TestCompletionCallback callback;
13173 13176
13174 // HTTP/2 (or SPDY) is required for alternative service, if HTTP/1.1 is 13177 // HTTP/2 (or SPDY) is required for alternative service, if HTTP/1.1 is
13175 // negotiated, the alternate Job should fail with ERR_ALPN_NEGOTIATION_FAILED. 13178 // negotiated, the alternate Job should fail with ERR_ALPN_NEGOTIATION_FAILED.
13176 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 13179 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
13177 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_ALPN_NEGOTIATION_FAILED)); 13180 EXPECT_THAT(callback.GetResult(rv), IsError(ERR_ALPN_NEGOTIATION_FAILED));
13178 } 13181 }
13179 13182
13180 // A request to a server with an alternative service fires two Jobs: one to the 13183 // A request to a server with an alternative service fires two Jobs: one to the
13181 // server, and an alternate one to the alternative server. If the former 13184 // server, and an alternate one to the alternative server. If the former
13182 // succeeds, the request should succeed, even if the latter fails because 13185 // succeeds, the request should succeed, even if the latter fails because
13183 // HTTP/1.1 is negotiated which is insufficient for alternative service. 13186 // HTTP/1.1 is negotiated which is insufficient for alternative service.
13184 TEST_F(HttpNetworkTransactionTest, FailedAlternativeServiceIsNotUserVisible) { 13187 TEST_F(HttpNetworkTransactionTest, FailedAlternativeServiceIsNotUserVisible) {
13185 url::SchemeHostPort server("https", "www.example.org", 443); 13188 url::SchemeHostPort server("https", "www.example.org", 443);
13186 HostPortPair alternative("www.example.org", 444); 13189 HostPortPair alternative("www.example.org", 444);
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after
13233 http_server_properties->SetAlternativeService(server, alternative_service, 13236 http_server_properties->SetAlternativeService(server, alternative_service,
13234 expiration); 13237 expiration);
13235 13238
13236 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 13239 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
13237 HttpRequestInfo request1; 13240 HttpRequestInfo request1;
13238 request1.method = "GET"; 13241 request1.method = "GET";
13239 request1.url = GURL("https://www.example.org:443"); 13242 request1.url = GURL("https://www.example.org:443");
13240 request1.load_flags = 0; 13243 request1.load_flags = 0;
13241 TestCompletionCallback callback1; 13244 TestCompletionCallback callback1;
13242 13245
13243 int rv = trans1.Start(&request1, callback1.callback(), BoundNetLog()); 13246 int rv = trans1.Start(&request1, callback1.callback(), NetLogWithSource());
13244 rv = callback1.GetResult(rv); 13247 rv = callback1.GetResult(rv);
13245 EXPECT_THAT(rv, IsOk()); 13248 EXPECT_THAT(rv, IsOk());
13246 13249
13247 const HttpResponseInfo* response1 = trans1.GetResponseInfo(); 13250 const HttpResponseInfo* response1 = trans1.GetResponseInfo();
13248 ASSERT_TRUE(response1); 13251 ASSERT_TRUE(response1);
13249 ASSERT_TRUE(response1->headers); 13252 ASSERT_TRUE(response1->headers);
13250 EXPECT_EQ("HTTP/1.1 200 OK", response1->headers->GetStatusLine()); 13253 EXPECT_EQ("HTTP/1.1 200 OK", response1->headers->GetStatusLine());
13251 13254
13252 std::string response_data1; 13255 std::string response_data1;
13253 ASSERT_THAT(ReadTransaction(&trans1, &response_data1), IsOk()); 13256 ASSERT_THAT(ReadTransaction(&trans1, &response_data1), IsOk());
13254 EXPECT_EQ("foobar", response_data1); 13257 EXPECT_EQ("foobar", response_data1);
13255 13258
13256 // Alternative should be marked as broken, because HTTP/1.1 is not sufficient 13259 // Alternative should be marked as broken, because HTTP/1.1 is not sufficient
13257 // for alternative service. 13260 // for alternative service.
13258 EXPECT_TRUE( 13261 EXPECT_TRUE(
13259 http_server_properties->IsAlternativeServiceBroken(alternative_service)); 13262 http_server_properties->IsAlternativeServiceBroken(alternative_service));
13260 13263
13261 // Since |alternative_service| is broken, a second transaction to server 13264 // Since |alternative_service| is broken, a second transaction to server
13262 // should not start an alternate Job. It should pool to existing connection 13265 // should not start an alternate Job. It should pool to existing connection
13263 // to server. 13266 // to server.
13264 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 13267 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
13265 HttpRequestInfo request2; 13268 HttpRequestInfo request2;
13266 request2.method = "GET"; 13269 request2.method = "GET";
13267 request2.url = GURL("https://www.example.org:443/second"); 13270 request2.url = GURL("https://www.example.org:443/second");
13268 request2.load_flags = 0; 13271 request2.load_flags = 0;
13269 TestCompletionCallback callback2; 13272 TestCompletionCallback callback2;
13270 13273
13271 rv = trans2.Start(&request2, callback2.callback(), BoundNetLog()); 13274 rv = trans2.Start(&request2, callback2.callback(), NetLogWithSource());
13272 rv = callback2.GetResult(rv); 13275 rv = callback2.GetResult(rv);
13273 EXPECT_THAT(rv, IsOk()); 13276 EXPECT_THAT(rv, IsOk());
13274 13277
13275 const HttpResponseInfo* response2 = trans2.GetResponseInfo(); 13278 const HttpResponseInfo* response2 = trans2.GetResponseInfo();
13276 ASSERT_TRUE(response2); 13279 ASSERT_TRUE(response2);
13277 ASSERT_TRUE(response2->headers); 13280 ASSERT_TRUE(response2->headers);
13278 EXPECT_EQ("HTTP/1.1 200 OK", response2->headers->GetStatusLine()); 13281 EXPECT_EQ("HTTP/1.1 200 OK", response2->headers->GetStatusLine());
13279 13282
13280 std::string response_data2; 13283 std::string response_data2;
13281 ASSERT_THAT(ReadTransaction(&trans2, &response_data2), IsOk()); 13284 ASSERT_THAT(ReadTransaction(&trans2, &response_data2), IsOk());
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
13342 expiration); 13345 expiration);
13343 13346
13344 // First transaction to alternative to open an HTTP/1.1 socket. 13347 // First transaction to alternative to open an HTTP/1.1 socket.
13345 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 13348 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
13346 HttpRequestInfo request1; 13349 HttpRequestInfo request1;
13347 request1.method = "GET"; 13350 request1.method = "GET";
13348 request1.url = GURL(alternative_url); 13351 request1.url = GURL(alternative_url);
13349 request1.load_flags = 0; 13352 request1.load_flags = 0;
13350 TestCompletionCallback callback1; 13353 TestCompletionCallback callback1;
13351 13354
13352 int rv = trans1.Start(&request1, callback1.callback(), BoundNetLog()); 13355 int rv = trans1.Start(&request1, callback1.callback(), NetLogWithSource());
13353 EXPECT_THAT(callback1.GetResult(rv), IsOk()); 13356 EXPECT_THAT(callback1.GetResult(rv), IsOk());
13354 const HttpResponseInfo* response1 = trans1.GetResponseInfo(); 13357 const HttpResponseInfo* response1 = trans1.GetResponseInfo();
13355 ASSERT_TRUE(response1); 13358 ASSERT_TRUE(response1);
13356 ASSERT_TRUE(response1->headers); 13359 ASSERT_TRUE(response1->headers);
13357 EXPECT_EQ("HTTP/1.1 200 OK", response1->headers->GetStatusLine()); 13360 EXPECT_EQ("HTTP/1.1 200 OK", response1->headers->GetStatusLine());
13358 EXPECT_TRUE(response1->was_alpn_negotiated); 13361 EXPECT_TRUE(response1->was_alpn_negotiated);
13359 EXPECT_FALSE(response1->was_fetched_via_spdy); 13362 EXPECT_FALSE(response1->was_fetched_via_spdy);
13360 std::string response_data1; 13363 std::string response_data1;
13361 ASSERT_THAT(ReadTransaction(&trans1, &response_data1), IsOk()); 13364 ASSERT_THAT(ReadTransaction(&trans1, &response_data1), IsOk());
13362 EXPECT_EQ("first HTTP/1.1 response from alternative", response_data1); 13365 EXPECT_EQ("first HTTP/1.1 response from alternative", response_data1);
13363 13366
13364 // Request for origin.example.org, which has an alternative service. This 13367 // Request for origin.example.org, which has an alternative service. This
13365 // will start two Jobs: the alternative looks for connections to pool to, 13368 // will start two Jobs: the alternative looks for connections to pool to,
13366 // finds one which is HTTP/1.1, and should ignore it, and should not try to 13369 // finds one which is HTTP/1.1, and should ignore it, and should not try to
13367 // open other connections to alternative server. The Job to server fails, so 13370 // open other connections to alternative server. The Job to server fails, so
13368 // this request fails. 13371 // this request fails.
13369 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 13372 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
13370 HttpRequestInfo request2; 13373 HttpRequestInfo request2;
13371 request2.method = "GET"; 13374 request2.method = "GET";
13372 request2.url = GURL(origin_url); 13375 request2.url = GURL(origin_url);
13373 request2.load_flags = 0; 13376 request2.load_flags = 0;
13374 TestCompletionCallback callback2; 13377 TestCompletionCallback callback2;
13375 13378
13376 rv = trans2.Start(&request2, callback2.callback(), BoundNetLog()); 13379 rv = trans2.Start(&request2, callback2.callback(), NetLogWithSource());
13377 EXPECT_THAT(callback2.GetResult(rv), IsError(ERR_CONNECTION_REFUSED)); 13380 EXPECT_THAT(callback2.GetResult(rv), IsError(ERR_CONNECTION_REFUSED));
13378 13381
13379 // Another transaction to alternative. This is to test that the HTTP/1.1 13382 // Another transaction to alternative. This is to test that the HTTP/1.1
13380 // socket is still open and in the pool. 13383 // socket is still open and in the pool.
13381 HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get()); 13384 HttpNetworkTransaction trans3(DEFAULT_PRIORITY, session.get());
13382 HttpRequestInfo request3; 13385 HttpRequestInfo request3;
13383 request3.method = "GET"; 13386 request3.method = "GET";
13384 request3.url = GURL(alternative_url); 13387 request3.url = GURL(alternative_url);
13385 request3.load_flags = 0; 13388 request3.load_flags = 0;
13386 TestCompletionCallback callback3; 13389 TestCompletionCallback callback3;
13387 13390
13388 rv = trans3.Start(&request3, callback3.callback(), BoundNetLog()); 13391 rv = trans3.Start(&request3, callback3.callback(), NetLogWithSource());
13389 EXPECT_THAT(callback3.GetResult(rv), IsOk()); 13392 EXPECT_THAT(callback3.GetResult(rv), IsOk());
13390 const HttpResponseInfo* response3 = trans3.GetResponseInfo(); 13393 const HttpResponseInfo* response3 = trans3.GetResponseInfo();
13391 ASSERT_TRUE(response3); 13394 ASSERT_TRUE(response3);
13392 ASSERT_TRUE(response3->headers); 13395 ASSERT_TRUE(response3->headers);
13393 EXPECT_EQ("HTTP/1.1 200 OK", response3->headers->GetStatusLine()); 13396 EXPECT_EQ("HTTP/1.1 200 OK", response3->headers->GetStatusLine());
13394 EXPECT_TRUE(response3->was_alpn_negotiated); 13397 EXPECT_TRUE(response3->was_alpn_negotiated);
13395 EXPECT_FALSE(response3->was_fetched_via_spdy); 13398 EXPECT_FALSE(response3->was_fetched_via_spdy);
13396 std::string response_data3; 13399 std::string response_data3;
13397 ASSERT_THAT(ReadTransaction(&trans3, &response_data3), IsOk()); 13400 ASSERT_THAT(ReadTransaction(&trans3, &response_data3), IsOk());
13398 EXPECT_EQ("second HTTP/1.1 response from alternative", response_data3); 13401 EXPECT_EQ("second HTTP/1.1 response from alternative", response_data3);
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
13469 13472
13470 std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_); 13473 std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
13471 13474
13472 // Start the first transaction to set up the SpdySession 13475 // Start the first transaction to set up the SpdySession
13473 HttpRequestInfo request1; 13476 HttpRequestInfo request1;
13474 request1.method = "GET"; 13477 request1.method = "GET";
13475 request1.url = GURL(https_url); 13478 request1.url = GURL(https_url);
13476 request1.load_flags = 0; 13479 request1.load_flags = 0;
13477 HttpNetworkTransaction trans1(LOWEST, session.get()); 13480 HttpNetworkTransaction trans1(LOWEST, session.get());
13478 TestCompletionCallback callback1; 13481 TestCompletionCallback callback1;
13479 int rv = trans1.Start(&request1, callback1.callback(), BoundNetLog()); 13482 int rv = trans1.Start(&request1, callback1.callback(), NetLogWithSource());
13480 13483
13481 // This pause is a hack to avoid running into https://crbug.com/497228. 13484 // This pause is a hack to avoid running into https://crbug.com/497228.
13482 data1.RunUntilPaused(); 13485 data1.RunUntilPaused();
13483 base::RunLoop().RunUntilIdle(); 13486 base::RunLoop().RunUntilIdle();
13484 data1.Resume(); 13487 data1.Resume();
13485 EXPECT_THAT(callback1.GetResult(rv), IsOk()); 13488 EXPECT_THAT(callback1.GetResult(rv), IsOk());
13486 EXPECT_TRUE(trans1.GetResponseInfo()->was_fetched_via_spdy); 13489 EXPECT_TRUE(trans1.GetResponseInfo()->was_fetched_via_spdy);
13487 13490
13488 LoadTimingInfo load_timing_info1; 13491 LoadTimingInfo load_timing_info1;
13489 EXPECT_TRUE(trans1.GetLoadTimingInfo(&load_timing_info1)); 13492 EXPECT_TRUE(trans1.GetLoadTimingInfo(&load_timing_info1));
13490 TestLoadTimingNotReusedWithPac(load_timing_info1, 13493 TestLoadTimingNotReusedWithPac(load_timing_info1,
13491 CONNECT_TIMING_HAS_SSL_TIMES); 13494 CONNECT_TIMING_HAS_SSL_TIMES);
13492 13495
13493 // Now, start the HTTP request. 13496 // Now, start the HTTP request.
13494 HttpRequestInfo request2; 13497 HttpRequestInfo request2;
13495 request2.method = "GET"; 13498 request2.method = "GET";
13496 request2.url = GURL(http_url); 13499 request2.url = GURL(http_url);
13497 request2.load_flags = 0; 13500 request2.load_flags = 0;
13498 HttpNetworkTransaction trans2(MEDIUM, session.get()); 13501 HttpNetworkTransaction trans2(MEDIUM, session.get());
13499 TestCompletionCallback callback2; 13502 TestCompletionCallback callback2;
13500 rv = trans2.Start(&request2, callback2.callback(), BoundNetLog()); 13503 rv = trans2.Start(&request2, callback2.callback(), NetLogWithSource());
13501 13504
13502 // This pause is a hack to avoid running into https://crbug.com/497228. 13505 // This pause is a hack to avoid running into https://crbug.com/497228.
13503 data1.RunUntilPaused(); 13506 data1.RunUntilPaused();
13504 base::RunLoop().RunUntilIdle(); 13507 base::RunLoop().RunUntilIdle();
13505 data1.Resume(); 13508 data1.Resume();
13506 EXPECT_THAT(callback2.GetResult(rv), IsOk()); 13509 EXPECT_THAT(callback2.GetResult(rv), IsOk());
13507 13510
13508 EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy); 13511 EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy);
13509 13512
13510 LoadTimingInfo load_timing_info2; 13513 LoadTimingInfo load_timing_info2;
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
13602 std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_); 13605 std::unique_ptr<HttpNetworkSession> session = CreateSession(&session_deps_);
13603 13606
13604 // Start the first transaction to set up the SpdySession 13607 // Start the first transaction to set up the SpdySession
13605 HttpRequestInfo request1; 13608 HttpRequestInfo request1;
13606 request1.method = "GET"; 13609 request1.method = "GET";
13607 request1.url = GURL(url1); 13610 request1.url = GURL(url1);
13608 request1.load_flags = 0; 13611 request1.load_flags = 0;
13609 HttpNetworkTransaction trans1(LOWEST, session.get()); 13612 HttpNetworkTransaction trans1(LOWEST, session.get());
13610 TestCompletionCallback callback1; 13613 TestCompletionCallback callback1;
13611 ASSERT_EQ(ERR_IO_PENDING, 13614 ASSERT_EQ(ERR_IO_PENDING,
13612 trans1.Start(&request1, callback1.callback(), BoundNetLog())); 13615 trans1.Start(&request1, callback1.callback(), NetLogWithSource()));
13613 // This pause is a hack to avoid running into https://crbug.com/497228. 13616 // This pause is a hack to avoid running into https://crbug.com/497228.
13614 data1.RunUntilPaused(); 13617 data1.RunUntilPaused();
13615 base::RunLoop().RunUntilIdle(); 13618 base::RunLoop().RunUntilIdle();
13616 data1.Resume(); 13619 data1.Resume();
13617 13620
13618 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 13621 EXPECT_THAT(callback1.WaitForResult(), IsOk());
13619 EXPECT_TRUE(trans1.GetResponseInfo()->was_fetched_via_spdy); 13622 EXPECT_TRUE(trans1.GetResponseInfo()->was_fetched_via_spdy);
13620 13623
13621 // Now, start the HTTP request 13624 // Now, start the HTTP request
13622 HttpRequestInfo request2; 13625 HttpRequestInfo request2;
13623 request2.method = "GET"; 13626 request2.method = "GET";
13624 request2.url = GURL(url2); 13627 request2.url = GURL(url2);
13625 request2.load_flags = 0; 13628 request2.load_flags = 0;
13626 HttpNetworkTransaction trans2(MEDIUM, session.get()); 13629 HttpNetworkTransaction trans2(MEDIUM, session.get());
13627 TestCompletionCallback callback2; 13630 TestCompletionCallback callback2;
13628 EXPECT_EQ(ERR_IO_PENDING, 13631 EXPECT_EQ(ERR_IO_PENDING,
13629 trans2.Start(&request2, callback2.callback(), BoundNetLog())); 13632 trans2.Start(&request2, callback2.callback(), NetLogWithSource()));
13630 base::RunLoop().RunUntilIdle(); 13633 base::RunLoop().RunUntilIdle();
13631 13634
13632 ASSERT_TRUE(callback2.have_result()); 13635 ASSERT_TRUE(callback2.have_result());
13633 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 13636 EXPECT_THAT(callback2.WaitForResult(), IsOk());
13634 EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy); 13637 EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy);
13635 } 13638 }
13636 13639
13637 // Test to verify that a failed socket read (due to an ERR_CONNECTION_CLOSED 13640 // Test to verify that a failed socket read (due to an ERR_CONNECTION_CLOSED
13638 // error) in SPDY session, removes the socket from pool and closes the SPDY 13641 // error) in SPDY session, removes the socket from pool and closes the SPDY
13639 // session. Verify that new url's from the same HttpNetworkSession (and a new 13642 // session. Verify that new url's from the same HttpNetworkSession (and a new
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
13678 13681
13679 // Start the first transaction to set up the SpdySession and verify that 13682 // Start the first transaction to set up the SpdySession and verify that
13680 // connection was closed. 13683 // connection was closed.
13681 HttpRequestInfo request1; 13684 HttpRequestInfo request1;
13682 request1.method = "GET"; 13685 request1.method = "GET";
13683 request1.url = GURL(https_url); 13686 request1.url = GURL(https_url);
13684 request1.load_flags = 0; 13687 request1.load_flags = 0;
13685 HttpNetworkTransaction trans1(MEDIUM, session.get()); 13688 HttpNetworkTransaction trans1(MEDIUM, session.get());
13686 TestCompletionCallback callback1; 13689 TestCompletionCallback callback1;
13687 EXPECT_EQ(ERR_IO_PENDING, 13690 EXPECT_EQ(ERR_IO_PENDING,
13688 trans1.Start(&request1, callback1.callback(), BoundNetLog())); 13691 trans1.Start(&request1, callback1.callback(), NetLogWithSource()));
13689 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_CONNECTION_CLOSED)); 13692 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
13690 13693
13691 // Now, start the second request and make sure it succeeds. 13694 // Now, start the second request and make sure it succeeds.
13692 HttpRequestInfo request2; 13695 HttpRequestInfo request2;
13693 request2.method = "GET"; 13696 request2.method = "GET";
13694 request2.url = GURL(https_url); 13697 request2.url = GURL(https_url);
13695 request2.load_flags = 0; 13698 request2.load_flags = 0;
13696 HttpNetworkTransaction trans2(MEDIUM, session.get()); 13699 HttpNetworkTransaction trans2(MEDIUM, session.get());
13697 TestCompletionCallback callback2; 13700 TestCompletionCallback callback2;
13698 EXPECT_EQ(ERR_IO_PENDING, 13701 EXPECT_EQ(ERR_IO_PENDING,
13699 trans2.Start(&request2, callback2.callback(), BoundNetLog())); 13702 trans2.Start(&request2, callback2.callback(), NetLogWithSource()));
13700 13703
13701 ASSERT_THAT(callback2.WaitForResult(), IsOk()); 13704 ASSERT_THAT(callback2.WaitForResult(), IsOk());
13702 EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy); 13705 EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy);
13703 } 13706 }
13704 13707
13705 TEST_F(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) { 13708 TEST_F(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) {
13706 ClientSocketPoolManager::set_max_sockets_per_group( 13709 ClientSocketPoolManager::set_max_sockets_per_group(
13707 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); 13710 HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
13708 ClientSocketPoolManager::set_max_sockets_per_pool( 13711 ClientSocketPoolManager::set_max_sockets_per_pool(
13709 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); 13712 HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after
13782 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a)); 13785 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
13783 13786
13784 TestCompletionCallback callback; 13787 TestCompletionCallback callback;
13785 HttpRequestInfo request1; 13788 HttpRequestInfo request1;
13786 request1.method = "GET"; 13789 request1.method = "GET";
13787 request1.url = GURL("https://www.a.com/"); 13790 request1.url = GURL("https://www.a.com/");
13788 request1.load_flags = 0; 13791 request1.load_flags = 0;
13789 std::unique_ptr<HttpNetworkTransaction> trans( 13792 std::unique_ptr<HttpNetworkTransaction> trans(
13790 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 13793 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
13791 13794
13792 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); 13795 int rv = trans->Start(&request1, callback.callback(), NetLogWithSource());
13793 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13796 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13794 EXPECT_THAT(callback.WaitForResult(), IsOk()); 13797 EXPECT_THAT(callback.WaitForResult(), IsOk());
13795 13798
13796 const HttpResponseInfo* response = trans->GetResponseInfo(); 13799 const HttpResponseInfo* response = trans->GetResponseInfo();
13797 ASSERT_TRUE(response); 13800 ASSERT_TRUE(response);
13798 ASSERT_TRUE(response->headers); 13801 ASSERT_TRUE(response->headers);
13799 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 13802 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
13800 EXPECT_TRUE(response->was_fetched_via_spdy); 13803 EXPECT_TRUE(response->was_fetched_via_spdy);
13801 EXPECT_TRUE(response->was_alpn_negotiated); 13804 EXPECT_TRUE(response->was_alpn_negotiated);
13802 13805
13803 std::string response_data; 13806 std::string response_data;
13804 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 13807 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
13805 EXPECT_EQ("hello!", response_data); 13808 EXPECT_EQ("hello!", response_data);
13806 trans.reset(); 13809 trans.reset();
13807 EXPECT_TRUE( 13810 EXPECT_TRUE(
13808 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a)); 13811 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
13809 13812
13810 HostPortPair host_port_pair_b("www.b.com", 443); 13813 HostPortPair host_port_pair_b("www.b.com", 443);
13811 SpdySessionKey spdy_session_key_b( 13814 SpdySessionKey spdy_session_key_b(
13812 host_port_pair_b, ProxyServer::Direct(), PRIVACY_MODE_DISABLED); 13815 host_port_pair_b, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
13813 EXPECT_FALSE( 13816 EXPECT_FALSE(
13814 HasSpdySession(session->spdy_session_pool(), spdy_session_key_b)); 13817 HasSpdySession(session->spdy_session_pool(), spdy_session_key_b));
13815 HttpRequestInfo request2; 13818 HttpRequestInfo request2;
13816 request2.method = "GET"; 13819 request2.method = "GET";
13817 request2.url = GURL("https://www.b.com/"); 13820 request2.url = GURL("https://www.b.com/");
13818 request2.load_flags = 0; 13821 request2.load_flags = 0;
13819 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 13822 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
13820 13823
13821 rv = trans->Start(&request2, callback.callback(), BoundNetLog()); 13824 rv = trans->Start(&request2, callback.callback(), NetLogWithSource());
13822 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13825 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13823 EXPECT_THAT(callback.WaitForResult(), IsOk()); 13826 EXPECT_THAT(callback.WaitForResult(), IsOk());
13824 13827
13825 response = trans->GetResponseInfo(); 13828 response = trans->GetResponseInfo();
13826 ASSERT_TRUE(response); 13829 ASSERT_TRUE(response);
13827 ASSERT_TRUE(response->headers); 13830 ASSERT_TRUE(response->headers);
13828 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine()); 13831 EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
13829 EXPECT_TRUE(response->was_fetched_via_spdy); 13832 EXPECT_TRUE(response->was_fetched_via_spdy);
13830 EXPECT_TRUE(response->was_alpn_negotiated); 13833 EXPECT_TRUE(response->was_alpn_negotiated);
13831 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 13834 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
13832 EXPECT_EQ("hello!", response_data); 13835 EXPECT_EQ("hello!", response_data);
13833 EXPECT_FALSE( 13836 EXPECT_FALSE(
13834 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a)); 13837 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a));
13835 EXPECT_TRUE( 13838 EXPECT_TRUE(
13836 HasSpdySession(session->spdy_session_pool(), spdy_session_key_b)); 13839 HasSpdySession(session->spdy_session_pool(), spdy_session_key_b));
13837 13840
13838 HostPortPair host_port_pair_a1("www.a.com", 80); 13841 HostPortPair host_port_pair_a1("www.a.com", 80);
13839 SpdySessionKey spdy_session_key_a1( 13842 SpdySessionKey spdy_session_key_a1(
13840 host_port_pair_a1, ProxyServer::Direct(), PRIVACY_MODE_DISABLED); 13843 host_port_pair_a1, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
13841 EXPECT_FALSE( 13844 EXPECT_FALSE(
13842 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a1)); 13845 HasSpdySession(session->spdy_session_pool(), spdy_session_key_a1));
13843 HttpRequestInfo request3; 13846 HttpRequestInfo request3;
13844 request3.method = "GET"; 13847 request3.method = "GET";
13845 request3.url = GURL("http://www.a.com/"); 13848 request3.url = GURL("http://www.a.com/");
13846 request3.load_flags = 0; 13849 request3.load_flags = 0;
13847 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 13850 trans.reset(new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
13848 13851
13849 rv = trans->Start(&request3, callback.callback(), BoundNetLog()); 13852 rv = trans->Start(&request3, callback.callback(), NetLogWithSource());
13850 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13853 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13851 EXPECT_THAT(callback.WaitForResult(), IsOk()); 13854 EXPECT_THAT(callback.WaitForResult(), IsOk());
13852 13855
13853 response = trans->GetResponseInfo(); 13856 response = trans->GetResponseInfo();
13854 ASSERT_TRUE(response); 13857 ASSERT_TRUE(response);
13855 ASSERT_TRUE(response->headers); 13858 ASSERT_TRUE(response->headers);
13856 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); 13859 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
13857 EXPECT_FALSE(response->was_fetched_via_spdy); 13860 EXPECT_FALSE(response->was_fetched_via_spdy);
13858 EXPECT_FALSE(response->was_alpn_negotiated); 13861 EXPECT_FALSE(response->was_alpn_negotiated);
13859 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk()); 13862 ASSERT_THAT(ReadTransaction(trans.get(), &response_data), IsOk());
(...skipping 13 matching lines...) Expand all
13873 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13876 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
13874 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 13877 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
13875 13878
13876 MockConnect mock_connect(SYNCHRONOUS, ERR_NAME_NOT_RESOLVED); 13879 MockConnect mock_connect(SYNCHRONOUS, ERR_NAME_NOT_RESOLVED);
13877 StaticSocketDataProvider data; 13880 StaticSocketDataProvider data;
13878 data.set_connect_data(mock_connect); 13881 data.set_connect_data(mock_connect);
13879 session_deps_.socket_factory->AddSocketDataProvider(&data); 13882 session_deps_.socket_factory->AddSocketDataProvider(&data);
13880 13883
13881 TestCompletionCallback callback; 13884 TestCompletionCallback callback;
13882 13885
13883 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 13886 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
13884 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13887 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13885 13888
13886 rv = callback.WaitForResult(); 13889 rv = callback.WaitForResult();
13887 EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED)); 13890 EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED));
13888 13891
13889 // We don't care whether this succeeds or fails, but it shouldn't crash. 13892 // We don't care whether this succeeds or fails, but it shouldn't crash.
13890 HttpRequestHeaders request_headers; 13893 HttpRequestHeaders request_headers;
13891 trans.GetFullRequestHeaders(&request_headers); 13894 trans.GetFullRequestHeaders(&request_headers);
13892 13895
13893 ConnectionAttempts attempts; 13896 ConnectionAttempts attempts;
(...skipping 15 matching lines...) Expand all
13909 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13912 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
13910 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 13913 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
13911 13914
13912 MockConnect mock_connect(ASYNC, ERR_NAME_NOT_RESOLVED); 13915 MockConnect mock_connect(ASYNC, ERR_NAME_NOT_RESOLVED);
13913 StaticSocketDataProvider data; 13916 StaticSocketDataProvider data;
13914 data.set_connect_data(mock_connect); 13917 data.set_connect_data(mock_connect);
13915 session_deps_.socket_factory->AddSocketDataProvider(&data); 13918 session_deps_.socket_factory->AddSocketDataProvider(&data);
13916 13919
13917 TestCompletionCallback callback; 13920 TestCompletionCallback callback;
13918 13921
13919 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 13922 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
13920 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13923 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13921 13924
13922 rv = callback.WaitForResult(); 13925 rv = callback.WaitForResult();
13923 EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED)); 13926 EXPECT_THAT(rv, IsError(ERR_NAME_NOT_RESOLVED));
13924 13927
13925 // We don't care whether this succeeds or fails, but it shouldn't crash. 13928 // We don't care whether this succeeds or fails, but it shouldn't crash.
13926 HttpRequestHeaders request_headers; 13929 HttpRequestHeaders request_headers;
13927 trans.GetFullRequestHeaders(&request_headers); 13930 trans.GetFullRequestHeaders(&request_headers);
13928 13931
13929 ConnectionAttempts attempts; 13932 ConnectionAttempts attempts;
(...skipping 21 matching lines...) Expand all
13951 MockRead data_reads[] = { 13954 MockRead data_reads[] = {
13952 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), // Should not be reached. 13955 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), // Should not be reached.
13953 }; 13956 };
13954 13957
13955 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 13958 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
13956 data_writes, arraysize(data_writes)); 13959 data_writes, arraysize(data_writes));
13957 session_deps_.socket_factory->AddSocketDataProvider(&data); 13960 session_deps_.socket_factory->AddSocketDataProvider(&data);
13958 13961
13959 TestCompletionCallback callback; 13962 TestCompletionCallback callback;
13960 13963
13961 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 13964 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
13962 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13965 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13963 13966
13964 rv = callback.WaitForResult(); 13967 rv = callback.WaitForResult();
13965 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 13968 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
13966 13969
13967 HttpRequestHeaders request_headers; 13970 HttpRequestHeaders request_headers;
13968 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers)); 13971 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers));
13969 EXPECT_TRUE(request_headers.HasHeader("Host")); 13972 EXPECT_TRUE(request_headers.HasHeader("Host"));
13970 } 13973 }
13971 13974
(...skipping 12 matching lines...) Expand all
13984 MockRead data_reads[] = { 13987 MockRead data_reads[] = {
13985 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), // Should not be reached. 13988 MockRead(SYNCHRONOUS, ERR_UNEXPECTED), // Should not be reached.
13986 }; 13989 };
13987 13990
13988 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 13991 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
13989 data_writes, arraysize(data_writes)); 13992 data_writes, arraysize(data_writes));
13990 session_deps_.socket_factory->AddSocketDataProvider(&data); 13993 session_deps_.socket_factory->AddSocketDataProvider(&data);
13991 13994
13992 TestCompletionCallback callback; 13995 TestCompletionCallback callback;
13993 13996
13994 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 13997 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
13995 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 13998 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
13996 13999
13997 rv = callback.WaitForResult(); 14000 rv = callback.WaitForResult();
13998 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 14001 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
13999 14002
14000 HttpRequestHeaders request_headers; 14003 HttpRequestHeaders request_headers;
14001 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers)); 14004 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers));
14002 EXPECT_TRUE(request_headers.HasHeader("Host")); 14005 EXPECT_TRUE(request_headers.HasHeader("Host"));
14003 } 14006 }
14004 14007
(...skipping 15 matching lines...) Expand all
14020 MockRead data_reads[] = { 14023 MockRead data_reads[] = {
14021 MockRead(SYNCHRONOUS, ERR_CONNECTION_RESET), 14024 MockRead(SYNCHRONOUS, ERR_CONNECTION_RESET),
14022 }; 14025 };
14023 14026
14024 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 14027 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
14025 data_writes, arraysize(data_writes)); 14028 data_writes, arraysize(data_writes));
14026 session_deps_.socket_factory->AddSocketDataProvider(&data); 14029 session_deps_.socket_factory->AddSocketDataProvider(&data);
14027 14030
14028 TestCompletionCallback callback; 14031 TestCompletionCallback callback;
14029 14032
14030 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 14033 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
14031 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14034 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14032 14035
14033 rv = callback.WaitForResult(); 14036 rv = callback.WaitForResult();
14034 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 14037 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
14035 14038
14036 HttpRequestHeaders request_headers; 14039 HttpRequestHeaders request_headers;
14037 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers)); 14040 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers));
14038 EXPECT_TRUE(request_headers.HasHeader("Host")); 14041 EXPECT_TRUE(request_headers.HasHeader("Host"));
14039 } 14042 }
14040 14043
(...skipping 15 matching lines...) Expand all
14056 MockRead data_reads[] = { 14059 MockRead data_reads[] = {
14057 MockRead(ASYNC, ERR_CONNECTION_RESET), 14060 MockRead(ASYNC, ERR_CONNECTION_RESET),
14058 }; 14061 };
14059 14062
14060 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 14063 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
14061 data_writes, arraysize(data_writes)); 14064 data_writes, arraysize(data_writes));
14062 session_deps_.socket_factory->AddSocketDataProvider(&data); 14065 session_deps_.socket_factory->AddSocketDataProvider(&data);
14063 14066
14064 TestCompletionCallback callback; 14067 TestCompletionCallback callback;
14065 14068
14066 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 14069 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
14067 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14070 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14068 14071
14069 rv = callback.WaitForResult(); 14072 rv = callback.WaitForResult();
14070 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 14073 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
14071 14074
14072 HttpRequestHeaders request_headers; 14075 HttpRequestHeaders request_headers;
14073 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers)); 14076 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers));
14074 EXPECT_TRUE(request_headers.HasHeader("Host")); 14077 EXPECT_TRUE(request_headers.HasHeader("Host"));
14075 } 14078 }
14076 14079
(...skipping 20 matching lines...) Expand all
14097 "hello"), 14100 "hello"),
14098 MockRead(ASYNC, ERR_UNEXPECTED), 14101 MockRead(ASYNC, ERR_UNEXPECTED),
14099 }; 14102 };
14100 14103
14101 StaticSocketDataProvider data(data_reads, arraysize(data_reads), 14104 StaticSocketDataProvider data(data_reads, arraysize(data_reads),
14102 data_writes, arraysize(data_writes)); 14105 data_writes, arraysize(data_writes));
14103 session_deps_.socket_factory->AddSocketDataProvider(&data); 14106 session_deps_.socket_factory->AddSocketDataProvider(&data);
14104 14107
14105 TestCompletionCallback callback; 14108 TestCompletionCallback callback;
14106 14109
14107 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 14110 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
14108 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14111 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14109 14112
14110 rv = callback.WaitForResult(); 14113 rv = callback.WaitForResult();
14111 EXPECT_THAT(rv, IsOk()); 14114 EXPECT_THAT(rv, IsOk());
14112 14115
14113 HttpRequestHeaders request_headers; 14116 HttpRequestHeaders request_headers;
14114 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers)); 14117 EXPECT_TRUE(trans.GetFullRequestHeaders(&request_headers));
14115 std::string foo; 14118 std::string foo;
14116 EXPECT_TRUE(request_headers.GetHeader("X-Foo", &foo)); 14119 EXPECT_TRUE(request_headers.GetHeader("X-Foo", &foo));
14117 EXPECT_EQ("bar", foo); 14120 EXPECT_EQ("bar", foo);
14118 } 14121 }
14119 14122
14120 namespace { 14123 namespace {
14121 14124
14122 // Fake HttpStream that simply records calls to SetPriority(). 14125 // Fake HttpStream that simply records calls to SetPriority().
14123 class FakeStream : public HttpStream, 14126 class FakeStream : public HttpStream,
14124 public base::SupportsWeakPtr<FakeStream> { 14127 public base::SupportsWeakPtr<FakeStream> {
14125 public: 14128 public:
14126 explicit FakeStream(RequestPriority priority) : priority_(priority) {} 14129 explicit FakeStream(RequestPriority priority) : priority_(priority) {}
14127 ~FakeStream() override {} 14130 ~FakeStream() override {}
14128 14131
14129 RequestPriority priority() const { return priority_; } 14132 RequestPriority priority() const { return priority_; }
14130 14133
14131 int InitializeStream(const HttpRequestInfo* request_info, 14134 int InitializeStream(const HttpRequestInfo* request_info,
14132 RequestPriority priority, 14135 RequestPriority priority,
14133 const BoundNetLog& net_log, 14136 const NetLogWithSource& net_log,
14134 const CompletionCallback& callback) override { 14137 const CompletionCallback& callback) override {
14135 return ERR_IO_PENDING; 14138 return ERR_IO_PENDING;
14136 } 14139 }
14137 14140
14138 int SendRequest(const HttpRequestHeaders& request_headers, 14141 int SendRequest(const HttpRequestHeaders& request_headers,
14139 HttpResponseInfo* response, 14142 HttpResponseInfo* response,
14140 const CompletionCallback& callback) override { 14143 const CompletionCallback& callback) override {
14141 ADD_FAILURE(); 14144 ADD_FAILURE();
14142 return ERR_UNEXPECTED; 14145 return ERR_UNEXPECTED;
14143 } 14146 }
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after
14293 // RequestStream() (which may be NULL if it was destroyed already). 14296 // RequestStream() (which may be NULL if it was destroyed already).
14294 base::WeakPtr<FakeStreamRequest> last_stream_request() { 14297 base::WeakPtr<FakeStreamRequest> last_stream_request() {
14295 return last_stream_request_; 14298 return last_stream_request_;
14296 } 14299 }
14297 14300
14298 HttpStreamRequest* RequestStream(const HttpRequestInfo& info, 14301 HttpStreamRequest* RequestStream(const HttpRequestInfo& info,
14299 RequestPriority priority, 14302 RequestPriority priority,
14300 const SSLConfig& server_ssl_config, 14303 const SSLConfig& server_ssl_config,
14301 const SSLConfig& proxy_ssl_config, 14304 const SSLConfig& proxy_ssl_config,
14302 HttpStreamRequest::Delegate* delegate, 14305 HttpStreamRequest::Delegate* delegate,
14303 const BoundNetLog& net_log) override { 14306 const NetLogWithSource& net_log) override {
14304 FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate); 14307 FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate);
14305 last_stream_request_ = fake_request->AsWeakPtr(); 14308 last_stream_request_ = fake_request->AsWeakPtr();
14306 return fake_request; 14309 return fake_request;
14307 } 14310 }
14308 14311
14309 HttpStreamRequest* RequestBidirectionalStreamImpl( 14312 HttpStreamRequest* RequestBidirectionalStreamImpl(
14310 const HttpRequestInfo& info, 14313 const HttpRequestInfo& info,
14311 RequestPriority priority, 14314 RequestPriority priority,
14312 const SSLConfig& server_ssl_config, 14315 const SSLConfig& server_ssl_config,
14313 const SSLConfig& proxy_ssl_config, 14316 const SSLConfig& proxy_ssl_config,
14314 HttpStreamRequest::Delegate* delegate, 14317 HttpStreamRequest::Delegate* delegate,
14315 const BoundNetLog& net_log) override { 14318 const NetLogWithSource& net_log) override {
14316 NOTREACHED(); 14319 NOTREACHED();
14317 return nullptr; 14320 return nullptr;
14318 } 14321 }
14319 14322
14320 HttpStreamRequest* RequestWebSocketHandshakeStream( 14323 HttpStreamRequest* RequestWebSocketHandshakeStream(
14321 const HttpRequestInfo& info, 14324 const HttpRequestInfo& info,
14322 RequestPriority priority, 14325 RequestPriority priority,
14323 const SSLConfig& server_ssl_config, 14326 const SSLConfig& server_ssl_config,
14324 const SSLConfig& proxy_ssl_config, 14327 const SSLConfig& proxy_ssl_config,
14325 HttpStreamRequest::Delegate* delegate, 14328 HttpStreamRequest::Delegate* delegate,
14326 WebSocketHandshakeStreamBase::CreateHelper* create_helper, 14329 WebSocketHandshakeStreamBase::CreateHelper* create_helper,
14327 const BoundNetLog& net_log) override { 14330 const NetLogWithSource& net_log) override {
14328 FakeStreamRequest* fake_request = 14331 FakeStreamRequest* fake_request =
14329 new FakeStreamRequest(priority, delegate, create_helper); 14332 new FakeStreamRequest(priority, delegate, create_helper);
14330 last_stream_request_ = fake_request->AsWeakPtr(); 14333 last_stream_request_ = fake_request->AsWeakPtr();
14331 return fake_request; 14334 return fake_request;
14332 } 14335 }
14333 14336
14334 void PreconnectStreams(int num_streams, 14337 void PreconnectStreams(int num_streams,
14335 const HttpRequestInfo& info) override { 14338 const HttpRequestInfo& info) override {
14336 ADD_FAILURE(); 14339 ADD_FAILURE();
14337 } 14340 }
(...skipping 18 matching lines...) Expand all
14356 bool using_proxy) 14359 bool using_proxy)
14357 : state_(std::move(connection), using_proxy, false) {} 14360 : state_(std::move(connection), using_proxy, false) {}
14358 14361
14359 // Fake implementation of HttpStreamBase methods. 14362 // Fake implementation of HttpStreamBase methods.
14360 // This ends up being quite "real" because this object has to really send data 14363 // This ends up being quite "real" because this object has to really send data
14361 // on the mock socket. It might be easier to use the real implementation, but 14364 // on the mock socket. It might be easier to use the real implementation, but
14362 // the fact that the WebSocket code is not compiled on iOS makes that 14365 // the fact that the WebSocket code is not compiled on iOS makes that
14363 // difficult. 14366 // difficult.
14364 int InitializeStream(const HttpRequestInfo* request_info, 14367 int InitializeStream(const HttpRequestInfo* request_info,
14365 RequestPriority priority, 14368 RequestPriority priority,
14366 const BoundNetLog& net_log, 14369 const NetLogWithSource& net_log,
14367 const CompletionCallback& callback) override { 14370 const CompletionCallback& callback) override {
14368 state_.Initialize(request_info, priority, net_log, callback); 14371 state_.Initialize(request_info, priority, net_log, callback);
14369 return OK; 14372 return OK;
14370 } 14373 }
14371 14374
14372 int SendRequest(const HttpRequestHeaders& request_headers, 14375 int SendRequest(const HttpRequestHeaders& request_headers,
14373 HttpResponseInfo* response, 14376 HttpResponseInfo* response,
14374 const CompletionCallback& callback) override { 14377 const CompletionCallback& callback) override {
14375 return parser()->SendRequest(state_.GenerateRequestLine(), request_headers, 14378 return parser()->SendRequest(state_.GenerateRequestLine(), request_headers,
14376 response, callback); 14379 response, callback);
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after
14496 FakeStreamFactory* fake_factory = new FakeStreamFactory(); 14499 FakeStreamFactory* fake_factory = new FakeStreamFactory();
14497 peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory)); 14500 peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory));
14498 14501
14499 HttpNetworkTransaction trans(LOW, session.get()); 14502 HttpNetworkTransaction trans(LOW, session.get());
14500 14503
14501 ASSERT_FALSE(fake_factory->last_stream_request()); 14504 ASSERT_FALSE(fake_factory->last_stream_request());
14502 14505
14503 HttpRequestInfo request; 14506 HttpRequestInfo request;
14504 TestCompletionCallback callback; 14507 TestCompletionCallback callback;
14505 EXPECT_EQ(ERR_IO_PENDING, 14508 EXPECT_EQ(ERR_IO_PENDING,
14506 trans.Start(&request, callback.callback(), BoundNetLog())); 14509 trans.Start(&request, callback.callback(), NetLogWithSource()));
14507 14510
14508 base::WeakPtr<FakeStreamRequest> fake_request = 14511 base::WeakPtr<FakeStreamRequest> fake_request =
14509 fake_factory->last_stream_request(); 14512 fake_factory->last_stream_request();
14510 ASSERT_TRUE(fake_request); 14513 ASSERT_TRUE(fake_request);
14511 EXPECT_EQ(LOW, fake_request->priority()); 14514 EXPECT_EQ(LOW, fake_request->priority());
14512 } 14515 }
14513 14516
14514 // Make sure that HttpNetworkTransaction passes on its priority 14517 // Make sure that HttpNetworkTransaction passes on its priority
14515 // updates to its stream request. 14518 // updates to its stream request.
14516 TEST_F(HttpNetworkTransactionTest, SetStreamRequestPriority) { 14519 TEST_F(HttpNetworkTransactionTest, SetStreamRequestPriority) {
14517 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 14520 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
14518 HttpNetworkSessionPeer peer(session.get()); 14521 HttpNetworkSessionPeer peer(session.get());
14519 FakeStreamFactory* fake_factory = new FakeStreamFactory(); 14522 FakeStreamFactory* fake_factory = new FakeStreamFactory();
14520 peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory)); 14523 peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory));
14521 14524
14522 HttpNetworkTransaction trans(LOW, session.get()); 14525 HttpNetworkTransaction trans(LOW, session.get());
14523 14526
14524 HttpRequestInfo request; 14527 HttpRequestInfo request;
14525 TestCompletionCallback callback; 14528 TestCompletionCallback callback;
14526 EXPECT_EQ(ERR_IO_PENDING, 14529 EXPECT_EQ(ERR_IO_PENDING,
14527 trans.Start(&request, callback.callback(), BoundNetLog())); 14530 trans.Start(&request, callback.callback(), NetLogWithSource()));
14528 14531
14529 base::WeakPtr<FakeStreamRequest> fake_request = 14532 base::WeakPtr<FakeStreamRequest> fake_request =
14530 fake_factory->last_stream_request(); 14533 fake_factory->last_stream_request();
14531 ASSERT_TRUE(fake_request); 14534 ASSERT_TRUE(fake_request);
14532 EXPECT_EQ(LOW, fake_request->priority()); 14535 EXPECT_EQ(LOW, fake_request->priority());
14533 14536
14534 trans.SetPriority(LOWEST); 14537 trans.SetPriority(LOWEST);
14535 ASSERT_TRUE(fake_request); 14538 ASSERT_TRUE(fake_request);
14536 EXPECT_EQ(LOWEST, fake_request->priority()); 14539 EXPECT_EQ(LOWEST, fake_request->priority());
14537 } 14540 }
14538 14541
14539 // Make sure that HttpNetworkTransaction passes on its priority 14542 // Make sure that HttpNetworkTransaction passes on its priority
14540 // updates to its stream. 14543 // updates to its stream.
14541 TEST_F(HttpNetworkTransactionTest, SetStreamPriority) { 14544 TEST_F(HttpNetworkTransactionTest, SetStreamPriority) {
14542 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 14545 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
14543 HttpNetworkSessionPeer peer(session.get()); 14546 HttpNetworkSessionPeer peer(session.get());
14544 FakeStreamFactory* fake_factory = new FakeStreamFactory(); 14547 FakeStreamFactory* fake_factory = new FakeStreamFactory();
14545 peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory)); 14548 peer.SetHttpStreamFactory(std::unique_ptr<HttpStreamFactory>(fake_factory));
14546 14549
14547 HttpNetworkTransaction trans(LOW, session.get()); 14550 HttpNetworkTransaction trans(LOW, session.get());
14548 14551
14549 HttpRequestInfo request; 14552 HttpRequestInfo request;
14550 TestCompletionCallback callback; 14553 TestCompletionCallback callback;
14551 EXPECT_EQ(ERR_IO_PENDING, 14554 EXPECT_EQ(ERR_IO_PENDING,
14552 trans.Start(&request, callback.callback(), BoundNetLog())); 14555 trans.Start(&request, callback.callback(), NetLogWithSource()));
14553 14556
14554 base::WeakPtr<FakeStreamRequest> fake_request = 14557 base::WeakPtr<FakeStreamRequest> fake_request =
14555 fake_factory->last_stream_request(); 14558 fake_factory->last_stream_request();
14556 ASSERT_TRUE(fake_request); 14559 ASSERT_TRUE(fake_request);
14557 base::WeakPtr<FakeStream> fake_stream = fake_request->FinishStreamRequest(); 14560 base::WeakPtr<FakeStream> fake_stream = fake_request->FinishStreamRequest();
14558 ASSERT_TRUE(fake_stream); 14561 ASSERT_TRUE(fake_stream);
14559 EXPECT_EQ(LOW, fake_stream->priority()); 14562 EXPECT_EQ(LOW, fake_stream->priority());
14560 14563
14561 trans.SetPriority(LOWEST); 14564 trans.SetPriority(LOWEST);
14562 EXPECT_EQ(LOWEST, fake_stream->priority()); 14565 EXPECT_EQ(LOWEST, fake_stream->priority());
(...skipping 16 matching lines...) Expand all
14579 HttpNetworkTransaction trans(LOW, session.get()); 14582 HttpNetworkTransaction trans(LOW, session.get());
14580 trans.SetWebSocketHandshakeStreamCreateHelper( 14583 trans.SetWebSocketHandshakeStreamCreateHelper(
14581 &websocket_stream_create_helper); 14584 &websocket_stream_create_helper);
14582 14585
14583 HttpRequestInfo request; 14586 HttpRequestInfo request;
14584 TestCompletionCallback callback; 14587 TestCompletionCallback callback;
14585 request.method = "GET"; 14588 request.method = "GET";
14586 request.url = GURL(test_cases[i]); 14589 request.url = GURL(test_cases[i]);
14587 14590
14588 EXPECT_EQ(ERR_IO_PENDING, 14591 EXPECT_EQ(ERR_IO_PENDING,
14589 trans.Start(&request, callback.callback(), BoundNetLog())); 14592 trans.Start(&request, callback.callback(), NetLogWithSource()));
14590 14593
14591 base::WeakPtr<FakeStreamRequest> fake_request = 14594 base::WeakPtr<FakeStreamRequest> fake_request =
14592 fake_factory->last_stream_request(); 14595 fake_factory->last_stream_request();
14593 ASSERT_TRUE(fake_request); 14596 ASSERT_TRUE(fake_request);
14594 EXPECT_EQ(&websocket_stream_create_helper, 14597 EXPECT_EQ(&websocket_stream_create_helper,
14595 fake_request->websocket_stream_create_helper()); 14598 fake_request->websocket_stream_create_helper());
14596 } 14599 }
14597 } 14600 }
14598 14601
14599 // Tests that when a used socket is returned to the SSL socket pool, it's closed 14602 // Tests that when a used socket is returned to the SSL socket pool, it's closed
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
14649 }; 14652 };
14650 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 14653 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
14651 http_writes, arraysize(http_writes)); 14654 http_writes, arraysize(http_writes));
14652 session_deps_.socket_factory->AddSocketDataProvider(&http_data); 14655 session_deps_.socket_factory->AddSocketDataProvider(&http_data);
14653 14656
14654 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 14657 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
14655 14658
14656 // Start the SSL request. 14659 // Start the SSL request.
14657 TestCompletionCallback ssl_callback; 14660 TestCompletionCallback ssl_callback;
14658 HttpNetworkTransaction ssl_trans(DEFAULT_PRIORITY, session.get()); 14661 HttpNetworkTransaction ssl_trans(DEFAULT_PRIORITY, session.get());
14659 ASSERT_EQ( 14662 ASSERT_EQ(ERR_IO_PENDING,
14660 ERR_IO_PENDING, 14663 ssl_trans.Start(&ssl_request, ssl_callback.callback(),
14661 ssl_trans.Start(&ssl_request, ssl_callback.callback(), BoundNetLog())); 14664 NetLogWithSource()));
14662 14665
14663 // Start the HTTP request. Pool should stall. 14666 // Start the HTTP request. Pool should stall.
14664 TestCompletionCallback http_callback; 14667 TestCompletionCallback http_callback;
14665 HttpNetworkTransaction http_trans(DEFAULT_PRIORITY, session.get()); 14668 HttpNetworkTransaction http_trans(DEFAULT_PRIORITY, session.get());
14666 ASSERT_EQ( 14669 ASSERT_EQ(ERR_IO_PENDING,
14667 ERR_IO_PENDING, 14670 http_trans.Start(&http_request, http_callback.callback(),
14668 http_trans.Start(&http_request, http_callback.callback(), BoundNetLog())); 14671 NetLogWithSource()));
14669 EXPECT_TRUE(IsTransportSocketPoolStalled(session.get())); 14672 EXPECT_TRUE(IsTransportSocketPoolStalled(session.get()));
14670 14673
14671 // Wait for response from SSL request. 14674 // Wait for response from SSL request.
14672 ASSERT_THAT(ssl_callback.WaitForResult(), IsOk()); 14675 ASSERT_THAT(ssl_callback.WaitForResult(), IsOk());
14673 std::string response_data; 14676 std::string response_data;
14674 ASSERT_THAT(ReadTransaction(&ssl_trans, &response_data), IsOk()); 14677 ASSERT_THAT(ReadTransaction(&ssl_trans, &response_data), IsOk());
14675 EXPECT_EQ("hello world", response_data); 14678 EXPECT_EQ("hello world", response_data);
14676 14679
14677 // The SSL socket should automatically be closed, so the HTTP request can 14680 // The SSL socket should automatically be closed, so the HTTP request can
14678 // start. 14681 // start.
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
14735 14738
14736 // Preconnect an SSL socket. A preconnect is needed because connect jobs are 14739 // Preconnect an SSL socket. A preconnect is needed because connect jobs are
14737 // cancelled when a normal transaction is cancelled. 14740 // cancelled when a normal transaction is cancelled.
14738 HttpStreamFactory* http_stream_factory = session->http_stream_factory(); 14741 HttpStreamFactory* http_stream_factory = session->http_stream_factory();
14739 http_stream_factory->PreconnectStreams(1, ssl_request); 14742 http_stream_factory->PreconnectStreams(1, ssl_request);
14740 EXPECT_EQ(0, GetIdleSocketCountInSSLSocketPool(session.get())); 14743 EXPECT_EQ(0, GetIdleSocketCountInSSLSocketPool(session.get()));
14741 14744
14742 // Start the HTTP request. Pool should stall. 14745 // Start the HTTP request. Pool should stall.
14743 TestCompletionCallback http_callback; 14746 TestCompletionCallback http_callback;
14744 HttpNetworkTransaction http_trans(DEFAULT_PRIORITY, session.get()); 14747 HttpNetworkTransaction http_trans(DEFAULT_PRIORITY, session.get());
14745 ASSERT_EQ( 14748 ASSERT_EQ(ERR_IO_PENDING,
14746 ERR_IO_PENDING, 14749 http_trans.Start(&http_request, http_callback.callback(),
14747 http_trans.Start(&http_request, http_callback.callback(), BoundNetLog())); 14750 NetLogWithSource()));
14748 EXPECT_TRUE(IsTransportSocketPoolStalled(session.get())); 14751 EXPECT_TRUE(IsTransportSocketPoolStalled(session.get()));
14749 14752
14750 // The SSL connection will automatically be closed once the connection is 14753 // The SSL connection will automatically be closed once the connection is
14751 // established, to let the HTTP request start. 14754 // established, to let the HTTP request start.
14752 ASSERT_THAT(http_callback.WaitForResult(), IsOk()); 14755 ASSERT_THAT(http_callback.WaitForResult(), IsOk());
14753 std::string response_data; 14756 std::string response_data;
14754 ASSERT_THAT(ReadTransaction(&http_trans, &response_data), IsOk()); 14757 ASSERT_THAT(ReadTransaction(&http_trans, &response_data), IsOk());
14755 EXPECT_EQ("falafel", response_data); 14758 EXPECT_EQ("falafel", response_data);
14756 14759
14757 EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get())); 14760 EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
(...skipping 26 matching lines...) Expand all
14784 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"), 14787 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"),
14785 MockRead("hello world"), 14788 MockRead("hello world"),
14786 MockRead(SYNCHRONOUS, OK), 14789 MockRead(SYNCHRONOUS, OK),
14787 }; 14790 };
14788 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 14791 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
14789 arraysize(data_writes)); 14792 arraysize(data_writes));
14790 session_deps_.socket_factory->AddSocketDataProvider(&data); 14793 session_deps_.socket_factory->AddSocketDataProvider(&data);
14791 14794
14792 TestCompletionCallback callback; 14795 TestCompletionCallback callback;
14793 14796
14794 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 14797 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
14795 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14798 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14796 14799
14797 rv = callback.WaitForResult(); 14800 rv = callback.WaitForResult();
14798 EXPECT_THAT(rv, IsOk()); 14801 EXPECT_THAT(rv, IsOk());
14799 14802
14800 const HttpResponseInfo* response = trans.GetResponseInfo(); 14803 const HttpResponseInfo* response = trans.GetResponseInfo();
14801 ASSERT_TRUE(response); 14804 ASSERT_TRUE(response);
14802 14805
14803 EXPECT_TRUE(response->headers); 14806 EXPECT_TRUE(response->headers);
14804 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); 14807 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine());
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
14839 session_deps_.socket_factory->AddSocketDataProvider(&data); 14842 session_deps_.socket_factory->AddSocketDataProvider(&data);
14840 14843
14841 TestCompletionCallback callback; 14844 TestCompletionCallback callback;
14842 HttpRequestInfo request1; 14845 HttpRequestInfo request1;
14843 request1.method = "GET"; 14846 request1.method = "GET";
14844 request1.url = GURL("http://www.foo.com/"); 14847 request1.url = GURL("http://www.foo.com/");
14845 request1.load_flags = 0; 14848 request1.load_flags = 0;
14846 14849
14847 std::unique_ptr<HttpNetworkTransaction> trans1( 14850 std::unique_ptr<HttpNetworkTransaction> trans1(
14848 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 14851 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
14849 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); 14852 int rv = trans1->Start(&request1, callback.callback(), NetLogWithSource());
14850 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14853 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14851 14854
14852 rv = callback.WaitForResult(); 14855 rv = callback.WaitForResult();
14853 EXPECT_THAT(rv, IsOk()); 14856 EXPECT_THAT(rv, IsOk());
14854 14857
14855 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); 14858 const HttpResponseInfo* response1 = trans1->GetResponseInfo();
14856 ASSERT_TRUE(response1); 14859 ASSERT_TRUE(response1);
14857 14860
14858 EXPECT_TRUE(response1->headers); 14861 EXPECT_TRUE(response1->headers);
14859 EXPECT_EQ("HTTP/1.1 200 Peachy", response1->headers->GetStatusLine()); 14862 EXPECT_EQ("HTTP/1.1 200 Peachy", response1->headers->GetStatusLine());
(...skipping 10 matching lines...) Expand all
14870 base::WrapUnique(new UploadBytesElementReader("foo", 3))); 14873 base::WrapUnique(new UploadBytesElementReader("foo", 3)));
14871 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); 14874 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0);
14872 14875
14873 HttpRequestInfo request2; 14876 HttpRequestInfo request2;
14874 request2.method = "POST"; 14877 request2.method = "POST";
14875 request2.url = GURL("http://www.foo.com/"); 14878 request2.url = GURL("http://www.foo.com/");
14876 request2.upload_data_stream = &upload_data_stream; 14879 request2.upload_data_stream = &upload_data_stream;
14877 request2.load_flags = 0; 14880 request2.load_flags = 0;
14878 14881
14879 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get()); 14882 HttpNetworkTransaction trans2(DEFAULT_PRIORITY, session.get());
14880 rv = trans2.Start(&request2, callback.callback(), BoundNetLog()); 14883 rv = trans2.Start(&request2, callback.callback(), NetLogWithSource());
14881 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14884 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14882 14885
14883 rv = callback.WaitForResult(); 14886 rv = callback.WaitForResult();
14884 EXPECT_THAT(rv, IsOk()); 14887 EXPECT_THAT(rv, IsOk());
14885 14888
14886 const HttpResponseInfo* response2 = trans2.GetResponseInfo(); 14889 const HttpResponseInfo* response2 = trans2.GetResponseInfo();
14887 ASSERT_TRUE(response2); 14890 ASSERT_TRUE(response2);
14888 14891
14889 EXPECT_TRUE(response2->headers); 14892 EXPECT_TRUE(response2->headers);
14890 EXPECT_EQ("HTTP/1.1 400 Not OK", response2->headers->GetStatusLine()); 14893 EXPECT_EQ("HTTP/1.1 400 Not OK", response2->headers->GetStatusLine());
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
14924 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"), 14927 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"),
14925 MockRead("hello world"), 14928 MockRead("hello world"),
14926 MockRead(SYNCHRONOUS, OK), 14929 MockRead(SYNCHRONOUS, OK),
14927 }; 14930 };
14928 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 14931 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
14929 arraysize(data_writes)); 14932 arraysize(data_writes));
14930 session_deps_.socket_factory->AddSocketDataProvider(&data); 14933 session_deps_.socket_factory->AddSocketDataProvider(&data);
14931 14934
14932 TestCompletionCallback callback; 14935 TestCompletionCallback callback;
14933 14936
14934 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 14937 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
14935 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14938 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14936 14939
14937 rv = callback.WaitForResult(); 14940 rv = callback.WaitForResult();
14938 EXPECT_THAT(rv, IsOk()); 14941 EXPECT_THAT(rv, IsOk());
14939 14942
14940 const HttpResponseInfo* response = trans.GetResponseInfo(); 14943 const HttpResponseInfo* response = trans.GetResponseInfo();
14941 ASSERT_TRUE(response); 14944 ASSERT_TRUE(response);
14942 14945
14943 EXPECT_TRUE(response->headers); 14946 EXPECT_TRUE(response->headers);
14944 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); 14947 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine());
(...skipping 30 matching lines...) Expand all
14975 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"), 14978 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"),
14976 MockRead("hello world"), 14979 MockRead("hello world"),
14977 MockRead(SYNCHRONOUS, OK), 14980 MockRead(SYNCHRONOUS, OK),
14978 }; 14981 };
14979 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 14982 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
14980 arraysize(data_writes)); 14983 arraysize(data_writes));
14981 session_deps_.socket_factory->AddSocketDataProvider(&data); 14984 session_deps_.socket_factory->AddSocketDataProvider(&data);
14982 14985
14983 TestCompletionCallback callback; 14986 TestCompletionCallback callback;
14984 14987
14985 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 14988 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
14986 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 14989 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
14987 // Make sure the headers are sent before adding a chunk. This ensures that 14990 // Make sure the headers are sent before adding a chunk. This ensures that
14988 // they can't be merged with the body in a single send. Not currently 14991 // they can't be merged with the body in a single send. Not currently
14989 // necessary since a chunked body is never merged with headers, but this makes 14992 // necessary since a chunked body is never merged with headers, but this makes
14990 // the test more future proof. 14993 // the test more future proof.
14991 base::RunLoop().RunUntilIdle(); 14994 base::RunLoop().RunUntilIdle();
14992 14995
14993 upload_data_stream.AppendData("last chunk", 10, true); 14996 upload_data_stream.AppendData("last chunk", 10, true);
14994 14997
14995 rv = callback.WaitForResult(); 14998 rv = callback.WaitForResult();
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
15035 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"), 15038 MockRead("HTTP/1.0 400 Not OK\r\n\r\n"),
15036 MockRead("hello world"), 15039 MockRead("hello world"),
15037 MockRead(SYNCHRONOUS, OK), 15040 MockRead(SYNCHRONOUS, OK),
15038 }; 15041 };
15039 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15042 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15040 arraysize(data_writes)); 15043 arraysize(data_writes));
15041 session_deps_.socket_factory->AddSocketDataProvider(&data); 15044 session_deps_.socket_factory->AddSocketDataProvider(&data);
15042 15045
15043 TestCompletionCallback callback; 15046 TestCompletionCallback callback;
15044 15047
15045 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 15048 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
15046 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15049 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15047 15050
15048 rv = callback.WaitForResult(); 15051 rv = callback.WaitForResult();
15049 EXPECT_THAT(rv, IsOk()); 15052 EXPECT_THAT(rv, IsOk());
15050 15053
15051 const HttpResponseInfo* response = trans.GetResponseInfo(); 15054 const HttpResponseInfo* response = trans.GetResponseInfo();
15052 ASSERT_TRUE(response); 15055 ASSERT_TRUE(response);
15053 15056
15054 EXPECT_TRUE(response->headers); 15057 EXPECT_TRUE(response->headers);
15055 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); 15058 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine());
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
15087 MockRead("HTTP/1.0 200 Just Dandy\r\n\r\n"), 15090 MockRead("HTTP/1.0 200 Just Dandy\r\n\r\n"),
15088 MockRead("hello world"), 15091 MockRead("hello world"),
15089 MockRead(SYNCHRONOUS, OK), 15092 MockRead(SYNCHRONOUS, OK),
15090 }; 15093 };
15091 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15094 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15092 arraysize(data_writes)); 15095 arraysize(data_writes));
15093 session_deps_.socket_factory->AddSocketDataProvider(&data); 15096 session_deps_.socket_factory->AddSocketDataProvider(&data);
15094 15097
15095 TestCompletionCallback callback; 15098 TestCompletionCallback callback;
15096 15099
15097 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 15100 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
15098 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15101 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15099 15102
15100 rv = callback.WaitForResult(); 15103 rv = callback.WaitForResult();
15101 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 15104 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
15102 } 15105 }
15103 15106
15104 TEST_F(HttpNetworkTransactionTest, 15107 TEST_F(HttpNetworkTransactionTest,
15105 PostIgnoresNonErrorResponseAfterResetAnd100) { 15108 PostIgnoresNonErrorResponseAfterResetAnd100) {
15106 std::vector<std::unique_ptr<UploadElementReader>> element_readers; 15109 std::vector<std::unique_ptr<UploadElementReader>> element_readers;
15107 element_readers.push_back( 15110 element_readers.push_back(
(...skipping 23 matching lines...) Expand all
15131 MockRead("Location: http://somewhere-else.com/\r\n"), 15134 MockRead("Location: http://somewhere-else.com/\r\n"),
15132 MockRead("Content-Length: 0\r\n\r\n"), 15135 MockRead("Content-Length: 0\r\n\r\n"),
15133 MockRead(SYNCHRONOUS, OK), 15136 MockRead(SYNCHRONOUS, OK),
15134 }; 15137 };
15135 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15138 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15136 arraysize(data_writes)); 15139 arraysize(data_writes));
15137 session_deps_.socket_factory->AddSocketDataProvider(&data); 15140 session_deps_.socket_factory->AddSocketDataProvider(&data);
15138 15141
15139 TestCompletionCallback callback; 15142 TestCompletionCallback callback;
15140 15143
15141 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 15144 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
15142 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15145 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15143 15146
15144 rv = callback.WaitForResult(); 15147 rv = callback.WaitForResult();
15145 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 15148 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
15146 } 15149 }
15147 15150
15148 TEST_F(HttpNetworkTransactionTest, PostIgnoresHttp09ResponseAfterReset) { 15151 TEST_F(HttpNetworkTransactionTest, PostIgnoresHttp09ResponseAfterReset) {
15149 std::vector<std::unique_ptr<UploadElementReader>> element_readers; 15152 std::vector<std::unique_ptr<UploadElementReader>> element_readers;
15150 element_readers.push_back( 15153 element_readers.push_back(
15151 base::MakeUnique<UploadBytesElementReader>("foo", 3)); 15154 base::MakeUnique<UploadBytesElementReader>("foo", 3));
(...skipping 19 matching lines...) Expand all
15171 MockRead data_reads[] = { 15174 MockRead data_reads[] = {
15172 MockRead("HTTP 0.9 rocks!"), 15175 MockRead("HTTP 0.9 rocks!"),
15173 MockRead(SYNCHRONOUS, OK), 15176 MockRead(SYNCHRONOUS, OK),
15174 }; 15177 };
15175 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15178 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15176 arraysize(data_writes)); 15179 arraysize(data_writes));
15177 session_deps_.socket_factory->AddSocketDataProvider(&data); 15180 session_deps_.socket_factory->AddSocketDataProvider(&data);
15178 15181
15179 TestCompletionCallback callback; 15182 TestCompletionCallback callback;
15180 15183
15181 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 15184 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
15182 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15185 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15183 15186
15184 rv = callback.WaitForResult(); 15187 rv = callback.WaitForResult();
15185 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 15188 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
15186 } 15189 }
15187 15190
15188 TEST_F(HttpNetworkTransactionTest, PostIgnoresPartial400HeadersAfterReset) { 15191 TEST_F(HttpNetworkTransactionTest, PostIgnoresPartial400HeadersAfterReset) {
15189 std::vector<std::unique_ptr<UploadElementReader>> element_readers; 15192 std::vector<std::unique_ptr<UploadElementReader>> element_readers;
15190 element_readers.push_back( 15193 element_readers.push_back(
15191 base::MakeUnique<UploadBytesElementReader>("foo", 3)); 15194 base::MakeUnique<UploadBytesElementReader>("foo", 3));
(...skipping 19 matching lines...) Expand all
15211 MockRead data_reads[] = { 15214 MockRead data_reads[] = {
15212 MockRead("HTTP/1.0 400 Not a Full Response\r\n"), 15215 MockRead("HTTP/1.0 400 Not a Full Response\r\n"),
15213 MockRead(SYNCHRONOUS, OK), 15216 MockRead(SYNCHRONOUS, OK),
15214 }; 15217 };
15215 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15218 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15216 arraysize(data_writes)); 15219 arraysize(data_writes));
15217 session_deps_.socket_factory->AddSocketDataProvider(&data); 15220 session_deps_.socket_factory->AddSocketDataProvider(&data);
15218 15221
15219 TestCompletionCallback callback; 15222 TestCompletionCallback callback;
15220 15223
15221 int rv = trans.Start(&request, callback.callback(), BoundNetLog()); 15224 int rv = trans.Start(&request, callback.callback(), NetLogWithSource());
15222 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15225 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15223 15226
15224 rv = callback.WaitForResult(); 15227 rv = callback.WaitForResult();
15225 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET)); 15228 EXPECT_THAT(rv, IsError(ERR_CONNECTION_RESET));
15226 } 15229 }
15227 15230
15228 // Verify that proxy headers are not sent to the destination server when 15231 // Verify that proxy headers are not sent to the destination server when
15229 // establishing a tunnel for a secure WebSocket connection. 15232 // establishing a tunnel for a secure WebSocket connection.
15230 TEST_F(HttpNetworkTransactionTest, ProxyHeadersNotSentOverWssTunnel) { 15233 TEST_F(HttpNetworkTransactionTest, ProxyHeadersNotSentOverWssTunnel) {
15231 HttpRequestInfo request; 15234 HttpRequestInfo request;
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
15286 15289
15287 std::unique_ptr<HttpNetworkTransaction> trans( 15290 std::unique_ptr<HttpNetworkTransaction> trans(
15288 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 15291 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
15289 FakeWebSocketStreamCreateHelper websocket_stream_create_helper; 15292 FakeWebSocketStreamCreateHelper websocket_stream_create_helper;
15290 trans->SetWebSocketHandshakeStreamCreateHelper( 15293 trans->SetWebSocketHandshakeStreamCreateHelper(
15291 &websocket_stream_create_helper); 15294 &websocket_stream_create_helper);
15292 15295
15293 { 15296 {
15294 TestCompletionCallback callback; 15297 TestCompletionCallback callback;
15295 15298
15296 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 15299 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
15297 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15300 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15298 15301
15299 rv = callback.WaitForResult(); 15302 rv = callback.WaitForResult();
15300 EXPECT_THAT(rv, IsOk()); 15303 EXPECT_THAT(rv, IsOk());
15301 } 15304 }
15302 15305
15303 const HttpResponseInfo* response = trans->GetResponseInfo(); 15306 const HttpResponseInfo* response = trans->GetResponseInfo();
15304 ASSERT_TRUE(response); 15307 ASSERT_TRUE(response);
15305 ASSERT_TRUE(response->headers); 15308 ASSERT_TRUE(response->headers);
15306 EXPECT_EQ(407, response->headers->response_code()); 15309 EXPECT_EQ(407, response->headers->response_code());
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after
15384 "Basic realm=MyRealm1", AuthCredentials(kFoo, kBar), "/"); 15387 "Basic realm=MyRealm1", AuthCredentials(kFoo, kBar), "/");
15385 15388
15386 std::unique_ptr<HttpNetworkTransaction> trans( 15389 std::unique_ptr<HttpNetworkTransaction> trans(
15387 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 15390 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
15388 FakeWebSocketStreamCreateHelper websocket_stream_create_helper; 15391 FakeWebSocketStreamCreateHelper websocket_stream_create_helper;
15389 trans->SetWebSocketHandshakeStreamCreateHelper( 15392 trans->SetWebSocketHandshakeStreamCreateHelper(
15390 &websocket_stream_create_helper); 15393 &websocket_stream_create_helper);
15391 15394
15392 TestCompletionCallback callback; 15395 TestCompletionCallback callback;
15393 15396
15394 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); 15397 int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
15395 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 15398 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
15396 15399
15397 rv = callback.WaitForResult(); 15400 rv = callback.WaitForResult();
15398 EXPECT_THAT(rv, IsOk()); 15401 EXPECT_THAT(rv, IsOk());
15399 15402
15400 const HttpResponseInfo* response = trans->GetResponseInfo(); 15403 const HttpResponseInfo* response = trans->GetResponseInfo();
15401 ASSERT_TRUE(response); 15404 ASSERT_TRUE(response);
15402 ASSERT_TRUE(response->headers); 15405 ASSERT_TRUE(response->headers);
15403 15406
15404 EXPECT_EQ(101, response->headers->response_code()); 15407 EXPECT_EQ(101, response->headers->response_code());
(...skipping 27 matching lines...) Expand all
15432 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"), 15435 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
15433 MockRead(SYNCHRONOUS, OK), 15436 MockRead(SYNCHRONOUS, OK),
15434 }; 15437 };
15435 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15438 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15436 arraysize(data_writes)); 15439 arraysize(data_writes));
15437 session_deps_.socket_factory->AddSocketDataProvider(&data); 15440 session_deps_.socket_factory->AddSocketDataProvider(&data);
15438 15441
15439 TestCompletionCallback callback; 15442 TestCompletionCallback callback;
15440 15443
15441 EXPECT_EQ(ERR_IO_PENDING, 15444 EXPECT_EQ(ERR_IO_PENDING,
15442 trans.Start(&request, callback.callback(), BoundNetLog())); 15445 trans.Start(&request, callback.callback(), NetLogWithSource()));
15443 EXPECT_THAT(callback.WaitForResult(), IsOk()); 15446 EXPECT_THAT(callback.WaitForResult(), IsOk());
15444 15447
15445 std::string response_data; 15448 std::string response_data;
15446 EXPECT_THAT(ReadTransaction(&trans, &response_data), IsOk()); 15449 EXPECT_THAT(ReadTransaction(&trans, &response_data), IsOk());
15447 15450
15448 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), 15451 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
15449 trans.GetTotalSentBytes()); 15452 trans.GetTotalSentBytes());
15450 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), 15453 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
15451 trans.GetTotalReceivedBytes()); 15454 trans.GetTotalReceivedBytes());
15452 } 15455 }
(...skipping 24 matching lines...) Expand all
15477 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"), 15480 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
15478 MockRead(SYNCHRONOUS, OK), 15481 MockRead(SYNCHRONOUS, OK),
15479 }; 15482 };
15480 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15483 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15481 arraysize(data_writes)); 15484 arraysize(data_writes));
15482 session_deps_.socket_factory->AddSocketDataProvider(&data); 15485 session_deps_.socket_factory->AddSocketDataProvider(&data);
15483 15486
15484 TestCompletionCallback callback; 15487 TestCompletionCallback callback;
15485 15488
15486 EXPECT_EQ(ERR_IO_PENDING, 15489 EXPECT_EQ(ERR_IO_PENDING,
15487 trans.Start(&request, callback.callback(), BoundNetLog())); 15490 trans.Start(&request, callback.callback(), NetLogWithSource()));
15488 EXPECT_THAT(callback.WaitForResult(), IsOk()); 15491 EXPECT_THAT(callback.WaitForResult(), IsOk());
15489 15492
15490 std::string response_data; 15493 std::string response_data;
15491 EXPECT_THAT(ReadTransaction(&trans, &response_data), IsOk()); 15494 EXPECT_THAT(ReadTransaction(&trans, &response_data), IsOk());
15492 15495
15493 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), 15496 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
15494 trans.GetTotalSentBytes()); 15497 trans.GetTotalSentBytes());
15495 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), 15498 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
15496 trans.GetTotalReceivedBytes()); 15499 trans.GetTotalReceivedBytes());
15497 } 15500 }
(...skipping 21 matching lines...) Expand all
15519 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"), 15522 MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
15520 MockRead(SYNCHRONOUS, OK), 15523 MockRead(SYNCHRONOUS, OK),
15521 }; 15524 };
15522 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes, 15525 StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
15523 arraysize(data_writes)); 15526 arraysize(data_writes));
15524 session_deps_.socket_factory->AddSocketDataProvider(&data); 15527 session_deps_.socket_factory->AddSocketDataProvider(&data);
15525 15528
15526 TestCompletionCallback callback; 15529 TestCompletionCallback callback;
15527 15530
15528 EXPECT_EQ(ERR_IO_PENDING, 15531 EXPECT_EQ(ERR_IO_PENDING,
15529 trans.Start(&request, callback.callback(), BoundNetLog())); 15532 trans.Start(&request, callback.callback(), NetLogWithSource()));
15530 15533
15531 base::RunLoop().RunUntilIdle(); 15534 base::RunLoop().RunUntilIdle();
15532 upload_data_stream.AppendData("f", 1, false); 15535 upload_data_stream.AppendData("f", 1, false);
15533 15536
15534 base::RunLoop().RunUntilIdle(); 15537 base::RunLoop().RunUntilIdle();
15535 upload_data_stream.AppendData("oo", 2, true); 15538 upload_data_stream.AppendData("oo", 2, true);
15536 15539
15537 EXPECT_THAT(callback.WaitForResult(), IsOk()); 15540 EXPECT_THAT(callback.WaitForResult(), IsOk());
15538 15541
15539 std::string response_data; 15542 std::string response_data;
(...skipping 24 matching lines...) Expand all
15564 MockRead(ASYNC, ERR_IO_PENDING)}; 15567 MockRead(ASYNC, ERR_IO_PENDING)};
15565 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); 15568 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
15566 session_deps_.socket_factory->AddSocketDataProvider(&data); 15569 session_deps_.socket_factory->AddSocketDataProvider(&data);
15567 session_deps_.channel_id_service.reset(new ChannelIDService( 15570 session_deps_.channel_id_service.reset(new ChannelIDService(
15568 new DefaultChannelIDStore(nullptr), base::ThreadTaskRunnerHandle::Get())); 15571 new DefaultChannelIDStore(nullptr), base::ThreadTaskRunnerHandle::Get()));
15569 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 15572 std::unique_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
15570 15573
15571 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); 15574 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get());
15572 TestCompletionCallback callback; 15575 TestCompletionCallback callback;
15573 EXPECT_EQ(ERR_IO_PENDING, 15576 EXPECT_EQ(ERR_IO_PENDING,
15574 trans.Start(&request, callback.callback(), BoundNetLog())); 15577 trans.Start(&request, callback.callback(), NetLogWithSource()));
15575 base::RunLoop().RunUntilIdle(); 15578 base::RunLoop().RunUntilIdle();
15576 15579
15577 EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy); 15580 EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
15578 HttpRequestHeaders headers; 15581 HttpRequestHeaders headers;
15579 ASSERT_TRUE(trans.GetFullRequestHeaders(&headers)); 15582 ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
15580 EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding)); 15583 EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
15581 } 15584 }
15582 #endif // !defined(OS_IOS) 15585 #endif // !defined(OS_IOS)
15583 15586
15584 } // namespace net 15587 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698