OLD | NEW |
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 1163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1174 EXPECT_TRUE(response->proxy_server.IsEmpty()); | 1174 EXPECT_TRUE(response->proxy_server.IsEmpty()); |
1175 | 1175 |
1176 std::string response_data; | 1176 std::string response_data; |
1177 rv = ReadTransaction(trans.get(), &response_data); | 1177 rv = ReadTransaction(trans.get(), &response_data); |
1178 EXPECT_EQ(OK, rv); | 1178 EXPECT_EQ(OK, rv); |
1179 EXPECT_EQ(kExpectedResponseData[i], response_data); | 1179 EXPECT_EQ(kExpectedResponseData[i], response_data); |
1180 } | 1180 } |
1181 } | 1181 } |
1182 | 1182 |
1183 TEST_P(HttpNetworkTransactionTest, Ignores100) { | 1183 TEST_P(HttpNetworkTransactionTest, Ignores100) { |
1184 ScopedVector<UploadElementReader> element_readers; | 1184 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
1185 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 1185 element_readers.push_back( |
1186 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 1186 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 1187 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
1187 | 1188 |
1188 HttpRequestInfo request; | 1189 HttpRequestInfo request; |
1189 request.method = "POST"; | 1190 request.method = "POST"; |
1190 request.url = GURL("http://www.foo.com/"); | 1191 request.url = GURL("http://www.foo.com/"); |
1191 request.upload_data_stream = &upload_data_stream; | 1192 request.upload_data_stream = &upload_data_stream; |
1192 request.load_flags = 0; | 1193 request.load_flags = 0; |
1193 | 1194 |
1194 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 1195 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
1195 scoped_ptr<HttpTransaction> trans( | 1196 scoped_ptr<HttpTransaction> trans( |
1196 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 1197 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 4809 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6006 | 6007 |
6007 // Empty the current queue. This is necessary because idle sockets are | 6008 // Empty the current queue. This is necessary because idle sockets are |
6008 // added to the connection pool asynchronously with a PostTask. | 6009 // added to the connection pool asynchronously with a PostTask. |
6009 base::MessageLoop::current()->RunUntilIdle(); | 6010 base::MessageLoop::current()->RunUntilIdle(); |
6010 | 6011 |
6011 // We now check to make sure the socket was added back to the pool. | 6012 // We now check to make sure the socket was added back to the pool. |
6012 EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get())); | 6013 EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get())); |
6013 } | 6014 } |
6014 | 6015 |
6015 TEST_P(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) { | 6016 TEST_P(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) { |
6016 ScopedVector<UploadElementReader> element_readers; | 6017 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
6017 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 6018 element_readers.push_back( |
6018 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 6019 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 6020 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
6019 | 6021 |
6020 HttpRequestInfo request[2]; | 6022 HttpRequestInfo request[2]; |
6021 // Transaction 1: a GET request that succeeds. The socket is recycled | 6023 // Transaction 1: a GET request that succeeds. The socket is recycled |
6022 // after use. | 6024 // after use. |
6023 request[0].method = "GET"; | 6025 request[0].method = "GET"; |
6024 request[0].url = GURL("http://www.google.com/"); | 6026 request[0].url = GURL("http://www.google.com/"); |
6025 request[0].load_flags = 0; | 6027 request[0].load_flags = 0; |
6026 // Transaction 2: a POST request. Reuses the socket kept alive from | 6028 // Transaction 2: a POST request. Reuses the socket kept alive from |
6027 // transaction 1. The first attempts fails when writing the POST data. | 6029 // transaction 1. The first attempts fails when writing the POST data. |
6028 // This causes the transaction to retry with a new socket. The second | 6030 // This causes the transaction to retry with a new socket. The second |
(...skipping 3072 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9101 EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv); | 9103 EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv); |
9102 } | 9104 } |
9103 | 9105 |
9104 TEST_P(HttpNetworkTransactionTest, UploadFileSmallerThanLength) { | 9106 TEST_P(HttpNetworkTransactionTest, UploadFileSmallerThanLength) { |
9105 base::FilePath temp_file_path; | 9107 base::FilePath temp_file_path; |
9106 ASSERT_TRUE(base::CreateTemporaryFile(&temp_file_path)); | 9108 ASSERT_TRUE(base::CreateTemporaryFile(&temp_file_path)); |
9107 const uint64 kFakeSize = 100000; // file is actually blank | 9109 const uint64 kFakeSize = 100000; // file is actually blank |
9108 UploadFileElementReader::ScopedOverridingContentLengthForTests | 9110 UploadFileElementReader::ScopedOverridingContentLengthForTests |
9109 overriding_content_length(kFakeSize); | 9111 overriding_content_length(kFakeSize); |
9110 | 9112 |
9111 ScopedVector<UploadElementReader> element_readers; | 9113 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
9112 element_readers.push_back( | 9114 element_readers.push_back(make_scoped_ptr(new UploadFileElementReader( |
9113 new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(), | 9115 base::ThreadTaskRunnerHandle::Get().get(), temp_file_path, 0, kuint64max, |
9114 temp_file_path, 0, kuint64max, base::Time())); | 9116 base::Time()))); |
9115 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 9117 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
9116 | 9118 |
9117 HttpRequestInfo request; | 9119 HttpRequestInfo request; |
9118 request.method = "POST"; | 9120 request.method = "POST"; |
9119 request.url = GURL("http://www.example.org/upload"); | 9121 request.url = GURL("http://www.example.org/upload"); |
9120 request.upload_data_stream = &upload_data_stream; | 9122 request.upload_data_stream = &upload_data_stream; |
9121 request.load_flags = 0; | 9123 request.load_flags = 0; |
9122 | 9124 |
9123 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 9125 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
9124 scoped_ptr<HttpTransaction> trans( | 9126 scoped_ptr<HttpTransaction> trans( |
9125 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 9127 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 29 matching lines...) Expand all Loading... |
9155 } | 9157 } |
9156 | 9158 |
9157 TEST_P(HttpNetworkTransactionTest, UploadUnreadableFile) { | 9159 TEST_P(HttpNetworkTransactionTest, UploadUnreadableFile) { |
9158 base::FilePath temp_file; | 9160 base::FilePath temp_file; |
9159 ASSERT_TRUE(base::CreateTemporaryFile(&temp_file)); | 9161 ASSERT_TRUE(base::CreateTemporaryFile(&temp_file)); |
9160 std::string temp_file_content("Unreadable file."); | 9162 std::string temp_file_content("Unreadable file."); |
9161 ASSERT_TRUE(base::WriteFile(temp_file, temp_file_content.c_str(), | 9163 ASSERT_TRUE(base::WriteFile(temp_file, temp_file_content.c_str(), |
9162 temp_file_content.length())); | 9164 temp_file_content.length())); |
9163 ASSERT_TRUE(base::MakeFileUnreadable(temp_file)); | 9165 ASSERT_TRUE(base::MakeFileUnreadable(temp_file)); |
9164 | 9166 |
9165 ScopedVector<UploadElementReader> element_readers; | 9167 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
9166 element_readers.push_back( | 9168 element_readers.push_back(make_scoped_ptr( |
9167 new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(), | 9169 new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(), |
9168 temp_file, 0, kuint64max, base::Time())); | 9170 temp_file, 0, kuint64max, base::Time()))); |
9169 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 9171 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
9170 | 9172 |
9171 HttpRequestInfo request; | 9173 HttpRequestInfo request; |
9172 request.method = "POST"; | 9174 request.method = "POST"; |
9173 request.url = GURL("http://www.example.org/upload"); | 9175 request.url = GURL("http://www.example.org/upload"); |
9174 request.upload_data_stream = &upload_data_stream; | 9176 request.upload_data_stream = &upload_data_stream; |
9175 request.load_flags = 0; | 9177 request.load_flags = 0; |
9176 | 9178 |
9177 // If we try to upload an unreadable file, the transaction should fail. | 9179 // If we try to upload an unreadable file, the transaction should fail. |
9178 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 9180 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
9179 scoped_ptr<HttpTransaction> trans( | 9181 scoped_ptr<HttpTransaction> trans( |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9212 int buf_length, | 9214 int buf_length, |
9213 const CompletionCallback& callback) override { | 9215 const CompletionCallback& callback) override { |
9214 return ERR_FAILED; | 9216 return ERR_FAILED; |
9215 } | 9217 } |
9216 | 9218 |
9217 private: | 9219 private: |
9218 CompletionCallback callback_; | 9220 CompletionCallback callback_; |
9219 }; | 9221 }; |
9220 | 9222 |
9221 FakeUploadElementReader* fake_reader = new FakeUploadElementReader; | 9223 FakeUploadElementReader* fake_reader = new FakeUploadElementReader; |
9222 ScopedVector<UploadElementReader> element_readers; | 9224 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
9223 element_readers.push_back(fake_reader); | 9225 element_readers.push_back(make_scoped_ptr(fake_reader)); |
9224 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 9226 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
9225 | 9227 |
9226 HttpRequestInfo request; | 9228 HttpRequestInfo request; |
9227 request.method = "POST"; | 9229 request.method = "POST"; |
9228 request.url = GURL("http://www.example.org/upload"); | 9230 request.url = GURL("http://www.example.org/upload"); |
9229 request.upload_data_stream = &upload_data_stream; | 9231 request.upload_data_stream = &upload_data_stream; |
9230 request.load_flags = 0; | 9232 request.load_flags = 0; |
9231 | 9233 |
9232 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 9234 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
9233 scoped_ptr<HttpTransaction> trans( | 9235 scoped_ptr<HttpTransaction> trans( |
9234 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 9236 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 5432 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14667 // established, to let the HTTP request start. | 14669 // established, to let the HTTP request start. |
14668 ASSERT_EQ(OK, http_callback.WaitForResult()); | 14670 ASSERT_EQ(OK, http_callback.WaitForResult()); |
14669 std::string response_data; | 14671 std::string response_data; |
14670 ASSERT_EQ(OK, ReadTransaction(http_trans.get(), &response_data)); | 14672 ASSERT_EQ(OK, ReadTransaction(http_trans.get(), &response_data)); |
14671 EXPECT_EQ("falafel", response_data); | 14673 EXPECT_EQ("falafel", response_data); |
14672 | 14674 |
14673 EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get())); | 14675 EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get())); |
14674 } | 14676 } |
14675 | 14677 |
14676 TEST_P(HttpNetworkTransactionTest, PostReadsErrorResponseAfterReset) { | 14678 TEST_P(HttpNetworkTransactionTest, PostReadsErrorResponseAfterReset) { |
14677 ScopedVector<UploadElementReader> element_readers; | 14679 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
14678 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 14680 element_readers.push_back( |
14679 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 14681 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 14682 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
14680 | 14683 |
14681 HttpRequestInfo request; | 14684 HttpRequestInfo request; |
14682 request.method = "POST"; | 14685 request.method = "POST"; |
14683 request.url = GURL("http://www.foo.com/"); | 14686 request.url = GURL("http://www.foo.com/"); |
14684 request.upload_data_stream = &upload_data_stream; | 14687 request.upload_data_stream = &upload_data_stream; |
14685 request.load_flags = 0; | 14688 request.load_flags = 0; |
14686 | 14689 |
14687 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 14690 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
14688 scoped_ptr<HttpTransaction> trans( | 14691 scoped_ptr<HttpTransaction> trans( |
14689 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 14692 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14774 EXPECT_TRUE(response1->headers.get() != NULL); | 14777 EXPECT_TRUE(response1->headers.get() != NULL); |
14775 EXPECT_EQ("HTTP/1.1 200 Peachy", response1->headers->GetStatusLine()); | 14778 EXPECT_EQ("HTTP/1.1 200 Peachy", response1->headers->GetStatusLine()); |
14776 | 14779 |
14777 std::string response_data1; | 14780 std::string response_data1; |
14778 rv = ReadTransaction(trans1.get(), &response_data1); | 14781 rv = ReadTransaction(trans1.get(), &response_data1); |
14779 EXPECT_EQ(OK, rv); | 14782 EXPECT_EQ(OK, rv); |
14780 EXPECT_EQ("first response", response_data1); | 14783 EXPECT_EQ("first response", response_data1); |
14781 // Delete the transaction to release the socket back into the socket pool. | 14784 // Delete the transaction to release the socket back into the socket pool. |
14782 trans1.reset(); | 14785 trans1.reset(); |
14783 | 14786 |
14784 ScopedVector<UploadElementReader> element_readers; | 14787 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
14785 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 14788 element_readers.push_back( |
14786 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 14789 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 14790 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
14787 | 14791 |
14788 HttpRequestInfo request2; | 14792 HttpRequestInfo request2; |
14789 request2.method = "POST"; | 14793 request2.method = "POST"; |
14790 request2.url = GURL("http://www.foo.com/"); | 14794 request2.url = GURL("http://www.foo.com/"); |
14791 request2.upload_data_stream = &upload_data_stream; | 14795 request2.upload_data_stream = &upload_data_stream; |
14792 request2.load_flags = 0; | 14796 request2.load_flags = 0; |
14793 | 14797 |
14794 scoped_ptr<HttpTransaction> trans2( | 14798 scoped_ptr<HttpTransaction> trans2( |
14795 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 14799 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
14796 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); | 14800 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); |
14797 EXPECT_EQ(ERR_IO_PENDING, rv); | 14801 EXPECT_EQ(ERR_IO_PENDING, rv); |
14798 | 14802 |
14799 rv = callback.WaitForResult(); | 14803 rv = callback.WaitForResult(); |
14800 EXPECT_EQ(OK, rv); | 14804 EXPECT_EQ(OK, rv); |
14801 | 14805 |
14802 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); | 14806 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); |
14803 ASSERT_TRUE(response2 != NULL); | 14807 ASSERT_TRUE(response2 != NULL); |
14804 | 14808 |
14805 EXPECT_TRUE(response2->headers.get() != NULL); | 14809 EXPECT_TRUE(response2->headers.get() != NULL); |
14806 EXPECT_EQ("HTTP/1.1 400 Not OK", response2->headers->GetStatusLine()); | 14810 EXPECT_EQ("HTTP/1.1 400 Not OK", response2->headers->GetStatusLine()); |
14807 | 14811 |
14808 std::string response_data2; | 14812 std::string response_data2; |
14809 rv = ReadTransaction(trans2.get(), &response_data2); | 14813 rv = ReadTransaction(trans2.get(), &response_data2); |
14810 EXPECT_EQ(OK, rv); | 14814 EXPECT_EQ(OK, rv); |
14811 EXPECT_EQ("second response", response_data2); | 14815 EXPECT_EQ("second response", response_data2); |
14812 } | 14816 } |
14813 | 14817 |
14814 TEST_P(HttpNetworkTransactionTest, | 14818 TEST_P(HttpNetworkTransactionTest, |
14815 PostReadsErrorResponseAfterResetPartialBodySent) { | 14819 PostReadsErrorResponseAfterResetPartialBodySent) { |
14816 ScopedVector<UploadElementReader> element_readers; | 14820 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
14817 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 14821 element_readers.push_back( |
14818 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 14822 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 14823 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
14819 | 14824 |
14820 HttpRequestInfo request; | 14825 HttpRequestInfo request; |
14821 request.method = "POST"; | 14826 request.method = "POST"; |
14822 request.url = GURL("http://www.foo.com/"); | 14827 request.url = GURL("http://www.foo.com/"); |
14823 request.upload_data_stream = &upload_data_stream; | 14828 request.upload_data_stream = &upload_data_stream; |
14824 request.load_flags = 0; | 14829 request.load_flags = 0; |
14825 | 14830 |
14826 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 14831 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
14827 scoped_ptr<HttpTransaction> trans( | 14832 scoped_ptr<HttpTransaction> trans( |
14828 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 14833 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14861 | 14866 |
14862 std::string response_data; | 14867 std::string response_data; |
14863 rv = ReadTransaction(trans.get(), &response_data); | 14868 rv = ReadTransaction(trans.get(), &response_data); |
14864 EXPECT_EQ(OK, rv); | 14869 EXPECT_EQ(OK, rv); |
14865 EXPECT_EQ("hello world", response_data); | 14870 EXPECT_EQ("hello world", response_data); |
14866 } | 14871 } |
14867 | 14872 |
14868 // This tests the more common case than the previous test, where headers and | 14873 // This tests the more common case than the previous test, where headers and |
14869 // body are not merged into a single request. | 14874 // body are not merged into a single request. |
14870 TEST_P(HttpNetworkTransactionTest, ChunkedPostReadsErrorResponseAfterReset) { | 14875 TEST_P(HttpNetworkTransactionTest, ChunkedPostReadsErrorResponseAfterReset) { |
14871 ScopedVector<UploadElementReader> element_readers; | |
14872 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | |
14873 ChunkedUploadDataStream upload_data_stream(0); | 14876 ChunkedUploadDataStream upload_data_stream(0); |
14874 | 14877 |
14875 HttpRequestInfo request; | 14878 HttpRequestInfo request; |
14876 request.method = "POST"; | 14879 request.method = "POST"; |
14877 request.url = GURL("http://www.foo.com/"); | 14880 request.url = GURL("http://www.foo.com/"); |
14878 request.upload_data_stream = &upload_data_stream; | 14881 request.upload_data_stream = &upload_data_stream; |
14879 request.load_flags = 0; | 14882 request.load_flags = 0; |
14880 | 14883 |
14881 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 14884 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
14882 scoped_ptr<HttpTransaction> trans( | 14885 scoped_ptr<HttpTransaction> trans( |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14920 EXPECT_TRUE(response->headers.get() != NULL); | 14923 EXPECT_TRUE(response->headers.get() != NULL); |
14921 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); | 14924 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); |
14922 | 14925 |
14923 std::string response_data; | 14926 std::string response_data; |
14924 rv = ReadTransaction(trans.get(), &response_data); | 14927 rv = ReadTransaction(trans.get(), &response_data); |
14925 EXPECT_EQ(OK, rv); | 14928 EXPECT_EQ(OK, rv); |
14926 EXPECT_EQ("hello world", response_data); | 14929 EXPECT_EQ("hello world", response_data); |
14927 } | 14930 } |
14928 | 14931 |
14929 TEST_P(HttpNetworkTransactionTest, PostReadsErrorResponseAfterResetAnd100) { | 14932 TEST_P(HttpNetworkTransactionTest, PostReadsErrorResponseAfterResetAnd100) { |
14930 ScopedVector<UploadElementReader> element_readers; | 14933 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
14931 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 14934 element_readers.push_back( |
14932 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 14935 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 14936 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
14933 | 14937 |
14934 HttpRequestInfo request; | 14938 HttpRequestInfo request; |
14935 request.method = "POST"; | 14939 request.method = "POST"; |
14936 request.url = GURL("http://www.foo.com/"); | 14940 request.url = GURL("http://www.foo.com/"); |
14937 request.upload_data_stream = &upload_data_stream; | 14941 request.upload_data_stream = &upload_data_stream; |
14938 request.load_flags = 0; | 14942 request.load_flags = 0; |
14939 | 14943 |
14940 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 14944 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
14941 scoped_ptr<HttpTransaction> trans( | 14945 scoped_ptr<HttpTransaction> trans( |
14942 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 14946 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 30 matching lines...) Expand all Loading... |
14973 EXPECT_TRUE(response->headers.get() != NULL); | 14977 EXPECT_TRUE(response->headers.get() != NULL); |
14974 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); | 14978 EXPECT_EQ("HTTP/1.0 400 Not OK", response->headers->GetStatusLine()); |
14975 | 14979 |
14976 std::string response_data; | 14980 std::string response_data; |
14977 rv = ReadTransaction(trans.get(), &response_data); | 14981 rv = ReadTransaction(trans.get(), &response_data); |
14978 EXPECT_EQ(OK, rv); | 14982 EXPECT_EQ(OK, rv); |
14979 EXPECT_EQ("hello world", response_data); | 14983 EXPECT_EQ("hello world", response_data); |
14980 } | 14984 } |
14981 | 14985 |
14982 TEST_P(HttpNetworkTransactionTest, PostIgnoresNonErrorResponseAfterReset) { | 14986 TEST_P(HttpNetworkTransactionTest, PostIgnoresNonErrorResponseAfterReset) { |
14983 ScopedVector<UploadElementReader> element_readers; | 14987 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
14984 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 14988 element_readers.push_back( |
14985 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 14989 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 14990 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
14986 | 14991 |
14987 HttpRequestInfo request; | 14992 HttpRequestInfo request; |
14988 request.method = "POST"; | 14993 request.method = "POST"; |
14989 request.url = GURL("http://www.foo.com/"); | 14994 request.url = GURL("http://www.foo.com/"); |
14990 request.upload_data_stream = &upload_data_stream; | 14995 request.upload_data_stream = &upload_data_stream; |
14991 request.load_flags = 0; | 14996 request.load_flags = 0; |
14992 | 14997 |
14993 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 14998 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
14994 scoped_ptr<HttpTransaction> trans( | 14999 scoped_ptr<HttpTransaction> trans( |
14995 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15000 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 19 matching lines...) Expand all Loading... |
15015 | 15020 |
15016 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); | 15021 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
15017 EXPECT_EQ(ERR_IO_PENDING, rv); | 15022 EXPECT_EQ(ERR_IO_PENDING, rv); |
15018 | 15023 |
15019 rv = callback.WaitForResult(); | 15024 rv = callback.WaitForResult(); |
15020 EXPECT_EQ(ERR_CONNECTION_RESET, rv); | 15025 EXPECT_EQ(ERR_CONNECTION_RESET, rv); |
15021 } | 15026 } |
15022 | 15027 |
15023 TEST_P(HttpNetworkTransactionTest, | 15028 TEST_P(HttpNetworkTransactionTest, |
15024 PostIgnoresNonErrorResponseAfterResetAnd100) { | 15029 PostIgnoresNonErrorResponseAfterResetAnd100) { |
15025 ScopedVector<UploadElementReader> element_readers; | 15030 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
15026 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 15031 element_readers.push_back( |
15027 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 15032 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 15033 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
15028 | 15034 |
15029 HttpRequestInfo request; | 15035 HttpRequestInfo request; |
15030 request.method = "POST"; | 15036 request.method = "POST"; |
15031 request.url = GURL("http://www.foo.com/"); | 15037 request.url = GURL("http://www.foo.com/"); |
15032 request.upload_data_stream = &upload_data_stream; | 15038 request.upload_data_stream = &upload_data_stream; |
15033 request.load_flags = 0; | 15039 request.load_flags = 0; |
15034 | 15040 |
15035 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15041 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15036 scoped_ptr<HttpTransaction> trans( | 15042 scoped_ptr<HttpTransaction> trans( |
15037 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15043 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 20 matching lines...) Expand all Loading... |
15058 TestCompletionCallback callback; | 15064 TestCompletionCallback callback; |
15059 | 15065 |
15060 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); | 15066 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
15061 EXPECT_EQ(ERR_IO_PENDING, rv); | 15067 EXPECT_EQ(ERR_IO_PENDING, rv); |
15062 | 15068 |
15063 rv = callback.WaitForResult(); | 15069 rv = callback.WaitForResult(); |
15064 EXPECT_EQ(ERR_CONNECTION_RESET, rv); | 15070 EXPECT_EQ(ERR_CONNECTION_RESET, rv); |
15065 } | 15071 } |
15066 | 15072 |
15067 TEST_P(HttpNetworkTransactionTest, PostIgnoresHttp09ResponseAfterReset) { | 15073 TEST_P(HttpNetworkTransactionTest, PostIgnoresHttp09ResponseAfterReset) { |
15068 ScopedVector<UploadElementReader> element_readers; | 15074 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
15069 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 15075 element_readers.push_back( |
15070 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 15076 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 15077 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
15071 | 15078 |
15072 HttpRequestInfo request; | 15079 HttpRequestInfo request; |
15073 request.method = "POST"; | 15080 request.method = "POST"; |
15074 request.url = GURL("http://www.foo.com/"); | 15081 request.url = GURL("http://www.foo.com/"); |
15075 request.upload_data_stream = &upload_data_stream; | 15082 request.upload_data_stream = &upload_data_stream; |
15076 request.load_flags = 0; | 15083 request.load_flags = 0; |
15077 | 15084 |
15078 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15085 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15079 scoped_ptr<HttpTransaction> trans( | 15086 scoped_ptr<HttpTransaction> trans( |
15080 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15087 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 17 matching lines...) Expand all Loading... |
15098 TestCompletionCallback callback; | 15105 TestCompletionCallback callback; |
15099 | 15106 |
15100 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); | 15107 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
15101 EXPECT_EQ(ERR_IO_PENDING, rv); | 15108 EXPECT_EQ(ERR_IO_PENDING, rv); |
15102 | 15109 |
15103 rv = callback.WaitForResult(); | 15110 rv = callback.WaitForResult(); |
15104 EXPECT_EQ(ERR_CONNECTION_RESET, rv); | 15111 EXPECT_EQ(ERR_CONNECTION_RESET, rv); |
15105 } | 15112 } |
15106 | 15113 |
15107 TEST_P(HttpNetworkTransactionTest, PostIgnoresPartial400HeadersAfterReset) { | 15114 TEST_P(HttpNetworkTransactionTest, PostIgnoresPartial400HeadersAfterReset) { |
15108 ScopedVector<UploadElementReader> element_readers; | 15115 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
15109 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 15116 element_readers.push_back( |
15110 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 15117 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 15118 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
15111 | 15119 |
15112 HttpRequestInfo request; | 15120 HttpRequestInfo request; |
15113 request.method = "POST"; | 15121 request.method = "POST"; |
15114 request.url = GURL("http://www.foo.com/"); | 15122 request.url = GURL("http://www.foo.com/"); |
15115 request.upload_data_stream = &upload_data_stream; | 15123 request.upload_data_stream = &upload_data_stream; |
15116 request.load_flags = 0; | 15124 request.load_flags = 0; |
15117 | 15125 |
15118 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15126 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15119 scoped_ptr<HttpTransaction> trans( | 15127 scoped_ptr<HttpTransaction> trans( |
15120 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15128 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 199 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
15320 ASSERT_TRUE(response); | 15328 ASSERT_TRUE(response); |
15321 ASSERT_TRUE(response->headers.get()); | 15329 ASSERT_TRUE(response->headers.get()); |
15322 | 15330 |
15323 EXPECT_EQ(101, response->headers->response_code()); | 15331 EXPECT_EQ(101, response->headers->response_code()); |
15324 | 15332 |
15325 trans.reset(); | 15333 trans.reset(); |
15326 session->CloseAllConnections(); | 15334 session->CloseAllConnections(); |
15327 } | 15335 } |
15328 | 15336 |
15329 TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesPost) { | 15337 TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesPost) { |
15330 ScopedVector<UploadElementReader> element_readers; | 15338 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
15331 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 15339 element_readers.push_back( |
15332 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 15340 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 15341 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
15333 | 15342 |
15334 HttpRequestInfo request; | 15343 HttpRequestInfo request; |
15335 request.method = "POST"; | 15344 request.method = "POST"; |
15336 request.url = GURL("http://www.foo.com/"); | 15345 request.url = GURL("http://www.foo.com/"); |
15337 request.upload_data_stream = &upload_data_stream; | 15346 request.upload_data_stream = &upload_data_stream; |
15338 | 15347 |
15339 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15348 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15340 scoped_ptr<HttpTransaction> trans( | 15349 scoped_ptr<HttpTransaction> trans( |
15341 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15350 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
15342 MockWrite data_writes[] = { | 15351 MockWrite data_writes[] = { |
(...skipping 21 matching lines...) Expand all Loading... |
15364 std::string response_data; | 15373 std::string response_data; |
15365 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 15374 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
15366 | 15375 |
15367 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), | 15376 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), |
15368 trans->GetTotalSentBytes()); | 15377 trans->GetTotalSentBytes()); |
15369 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), | 15378 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), |
15370 trans->GetTotalReceivedBytes()); | 15379 trans->GetTotalReceivedBytes()); |
15371 } | 15380 } |
15372 | 15381 |
15373 TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesPost100Continue) { | 15382 TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesPost100Continue) { |
15374 ScopedVector<UploadElementReader> element_readers; | 15383 std::vector<scoped_ptr<UploadElementReader>> element_readers; |
15375 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | 15384 element_readers.push_back( |
15376 ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0); | 15385 make_scoped_ptr(new UploadBytesElementReader("foo", 3))); |
| 15386 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
15377 | 15387 |
15378 HttpRequestInfo request; | 15388 HttpRequestInfo request; |
15379 request.method = "POST"; | 15389 request.method = "POST"; |
15380 request.url = GURL("http://www.foo.com/"); | 15390 request.url = GURL("http://www.foo.com/"); |
15381 request.upload_data_stream = &upload_data_stream; | 15391 request.upload_data_stream = &upload_data_stream; |
15382 | 15392 |
15383 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15393 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15384 scoped_ptr<HttpTransaction> trans( | 15394 scoped_ptr<HttpTransaction> trans( |
15385 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15395 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
15386 MockWrite data_writes[] = { | 15396 MockWrite data_writes[] = { |
(...skipping 22 matching lines...) Expand all Loading... |
15409 std::string response_data; | 15419 std::string response_data; |
15410 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 15420 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
15411 | 15421 |
15412 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), | 15422 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), |
15413 trans->GetTotalSentBytes()); | 15423 trans->GetTotalSentBytes()); |
15414 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), | 15424 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), |
15415 trans->GetTotalReceivedBytes()); | 15425 trans->GetTotalReceivedBytes()); |
15416 } | 15426 } |
15417 | 15427 |
15418 TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesChunkedPost) { | 15428 TEST_P(HttpNetworkTransactionTest, TotalNetworkBytesChunkedPost) { |
15419 ScopedVector<UploadElementReader> element_readers; | |
15420 element_readers.push_back(new UploadBytesElementReader("foo", 3)); | |
15421 ChunkedUploadDataStream upload_data_stream(0); | 15429 ChunkedUploadDataStream upload_data_stream(0); |
15422 | 15430 |
15423 HttpRequestInfo request; | 15431 HttpRequestInfo request; |
15424 request.method = "POST"; | 15432 request.method = "POST"; |
15425 request.url = GURL("http://www.foo.com/"); | 15433 request.url = GURL("http://www.foo.com/"); |
15426 request.upload_data_stream = &upload_data_stream; | 15434 request.upload_data_stream = &upload_data_stream; |
15427 | 15435 |
15428 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15436 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15429 scoped_ptr<HttpTransaction> trans( | 15437 scoped_ptr<HttpTransaction> trans( |
15430 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 15438 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
15486 | 15494 |
15487 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 15495 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
15488 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); | 15496 HttpNetworkTransaction trans(DEFAULT_PRIORITY, session.get()); |
15489 | 15497 |
15490 EXPECT_THAT(trans.server_ssl_config_.alpn_protos, | 15498 EXPECT_THAT(trans.server_ssl_config_.alpn_protos, |
15491 testing::ElementsAre(kProtoHTTP2, kProtoSPDY31, kProtoHTTP11)); | 15499 testing::ElementsAre(kProtoHTTP2, kProtoSPDY31, kProtoHTTP11)); |
15492 EXPECT_TRUE(trans.server_ssl_config_.npn_protos.empty()); | 15500 EXPECT_TRUE(trans.server_ssl_config_.npn_protos.empty()); |
15493 } | 15501 } |
15494 | 15502 |
15495 } // namespace net | 15503 } // namespace net |
OLD | NEW |