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 #include <limits> | 10 #include <limits> |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
45 #include "net/http/http_auth_challenge_tokenizer.h" | 45 #include "net/http/http_auth_challenge_tokenizer.h" |
46 #include "net/http/http_auth_handler_digest.h" | 46 #include "net/http/http_auth_handler_digest.h" |
47 #include "net/http/http_auth_handler_mock.h" | 47 #include "net/http/http_auth_handler_mock.h" |
48 #include "net/http/http_auth_handler_ntlm.h" | 48 #include "net/http/http_auth_handler_ntlm.h" |
49 #include "net/http/http_auth_scheme.h" | 49 #include "net/http/http_auth_scheme.h" |
50 #include "net/http/http_basic_state.h" | 50 #include "net/http/http_basic_state.h" |
51 #include "net/http/http_basic_stream.h" | 51 #include "net/http/http_basic_stream.h" |
52 #include "net/http/http_network_session.h" | 52 #include "net/http/http_network_session.h" |
53 #include "net/http/http_network_session_peer.h" | 53 #include "net/http/http_network_session_peer.h" |
54 #include "net/http/http_request_headers.h" | 54 #include "net/http/http_request_headers.h" |
| 55 #include "net/http/http_response_info.h" |
55 #include "net/http/http_server_properties_impl.h" | 56 #include "net/http/http_server_properties_impl.h" |
56 #include "net/http/http_stream.h" | 57 #include "net/http/http_stream.h" |
57 #include "net/http/http_stream_factory.h" | 58 #include "net/http/http_stream_factory.h" |
58 #include "net/http/http_stream_parser.h" | 59 #include "net/http/http_stream_parser.h" |
59 #include "net/http/http_transaction_test_util.h" | 60 #include "net/http/http_transaction_test_util.h" |
60 #include "net/log/net_log.h" | 61 #include "net/log/net_log.h" |
61 #include "net/log/test_net_log.h" | 62 #include "net/log/test_net_log.h" |
62 #include "net/log/test_net_log_entry.h" | 63 #include "net/log/test_net_log_entry.h" |
63 #include "net/log/test_net_log_util.h" | 64 #include "net/log/test_net_log_util.h" |
64 #include "net/proxy/mock_proxy_resolver.h" | 65 #include "net/proxy/mock_proxy_resolver.h" |
(...skipping 1899 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1964 const HttpResponseInfo* response = trans->GetResponseInfo(); | 1965 const HttpResponseInfo* response = trans->GetResponseInfo(); |
1965 ASSERT_TRUE(response); | 1966 ASSERT_TRUE(response); |
1966 ASSERT_TRUE(response->headers); | 1967 ASSERT_TRUE(response->headers); |
1967 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); | 1968 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
1968 std::string response_data; | 1969 std::string response_data; |
1969 rv = ReadTransaction(trans.get(), &response_data); | 1970 rv = ReadTransaction(trans.get(), &response_data); |
1970 EXPECT_EQ(OK, rv); | 1971 EXPECT_EQ(OK, rv); |
1971 EXPECT_EQ("hello", response_data); | 1972 EXPECT_EQ("hello", response_data); |
1972 } | 1973 } |
1973 | 1974 |
| 1975 // Sockets that receive extra data after a response is complete should not be |
| 1976 // reused. |
| 1977 TEST_P(HttpNetworkTransactionTest, KeepAliveWithUnusedData1) { |
| 1978 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
| 1979 MockWrite data_writes1[] = { |
| 1980 MockWrite("HEAD / HTTP/1.1\r\n" |
| 1981 "Host: www.borked.com\r\n" |
| 1982 "Connection: keep-alive\r\n\r\n"), |
| 1983 }; |
| 1984 |
| 1985 MockRead data_reads1[] = { |
| 1986 MockRead("HTTP/1.1 200 OK\r\n" |
| 1987 "Connection: keep-alive\r\n" |
| 1988 "Content-Length: 22\r\n\r\n" |
| 1989 "This server is borked."), |
| 1990 }; |
| 1991 |
| 1992 MockWrite data_writes2[] = { |
| 1993 MockWrite("GET /foo HTTP/1.1\r\n" |
| 1994 "Host: www.borked.com\r\n" |
| 1995 "Connection: keep-alive\r\n\r\n"), |
| 1996 }; |
| 1997 |
| 1998 MockRead data_reads2[] = { |
| 1999 MockRead("HTTP/1.1 200 OK\r\n" |
| 2000 "Content-Length: 3\r\n\r\n" |
| 2001 "foo"), |
| 2002 }; |
| 2003 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 2004 data_writes1, arraysize(data_writes1)); |
| 2005 session_deps_.socket_factory->AddSocketDataProvider(&data1); |
| 2006 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 2007 data_writes2, arraysize(data_writes2)); |
| 2008 session_deps_.socket_factory->AddSocketDataProvider(&data2); |
| 2009 |
| 2010 TestCompletionCallback callback; |
| 2011 HttpRequestInfo request1; |
| 2012 request1.method = "HEAD"; |
| 2013 request1.url = GURL("http://www.borked.com/"); |
| 2014 |
| 2015 scoped_ptr<HttpTransaction> trans1( |
| 2016 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2017 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); |
| 2018 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2019 |
| 2020 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); |
| 2021 ASSERT_TRUE(response1); |
| 2022 ASSERT_TRUE(response1->headers); |
| 2023 EXPECT_EQ(200, response1->headers->response_code()); |
| 2024 EXPECT_TRUE(response1->headers->IsKeepAlive()); |
| 2025 |
| 2026 std::string response_data1; |
| 2027 EXPECT_EQ(OK, ReadTransaction(trans1.get(), &response_data1)); |
| 2028 EXPECT_EQ("", response_data1); |
| 2029 // Deleting the transaction attempts to release the socket back into the |
| 2030 // socket pool. |
| 2031 trans1.reset(); |
| 2032 |
| 2033 HttpRequestInfo request2; |
| 2034 request2.method = "GET"; |
| 2035 request2.url = GURL("http://www.borked.com/foo"); |
| 2036 |
| 2037 scoped_ptr<HttpTransaction> trans2( |
| 2038 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2039 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); |
| 2040 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2041 |
| 2042 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); |
| 2043 ASSERT_TRUE(response2); |
| 2044 ASSERT_TRUE(response2->headers); |
| 2045 EXPECT_EQ(200, response2->headers->response_code()); |
| 2046 |
| 2047 std::string response_data2; |
| 2048 EXPECT_EQ(OK, ReadTransaction(trans2.get(), &response_data2)); |
| 2049 EXPECT_EQ("foo", response_data2); |
| 2050 } |
| 2051 |
| 2052 TEST_P(HttpNetworkTransactionTest, KeepAliveWithUnusedData2) { |
| 2053 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
| 2054 MockWrite data_writes1[] = { |
| 2055 MockWrite("GET / HTTP/1.1\r\n" |
| 2056 "Host: www.borked.com\r\n" |
| 2057 "Connection: keep-alive\r\n\r\n"), |
| 2058 }; |
| 2059 |
| 2060 MockRead data_reads1[] = { |
| 2061 MockRead("HTTP/1.1 200 OK\r\n" |
| 2062 "Connection: keep-alive\r\n" |
| 2063 "Content-Length: 22\r\n\r\n" |
| 2064 "This server is borked." |
| 2065 "Bonus data!"), |
| 2066 }; |
| 2067 |
| 2068 MockWrite data_writes2[] = { |
| 2069 MockWrite("GET /foo HTTP/1.1\r\n" |
| 2070 "Host: www.borked.com\r\n" |
| 2071 "Connection: keep-alive\r\n\r\n"), |
| 2072 }; |
| 2073 |
| 2074 MockRead data_reads2[] = { |
| 2075 MockRead("HTTP/1.1 200 OK\r\n" |
| 2076 "Content-Length: 3\r\n\r\n" |
| 2077 "foo"), |
| 2078 }; |
| 2079 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 2080 data_writes1, arraysize(data_writes1)); |
| 2081 session_deps_.socket_factory->AddSocketDataProvider(&data1); |
| 2082 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 2083 data_writes2, arraysize(data_writes2)); |
| 2084 session_deps_.socket_factory->AddSocketDataProvider(&data2); |
| 2085 |
| 2086 TestCompletionCallback callback; |
| 2087 HttpRequestInfo request1; |
| 2088 request1.method = "GET"; |
| 2089 request1.url = GURL("http://www.borked.com/"); |
| 2090 |
| 2091 scoped_ptr<HttpTransaction> trans1( |
| 2092 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2093 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); |
| 2094 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2095 |
| 2096 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); |
| 2097 ASSERT_TRUE(response1); |
| 2098 ASSERT_TRUE(response1->headers); |
| 2099 EXPECT_EQ(200, response1->headers->response_code()); |
| 2100 EXPECT_TRUE(response1->headers->IsKeepAlive()); |
| 2101 |
| 2102 std::string response_data1; |
| 2103 EXPECT_EQ(OK, ReadTransaction(trans1.get(), &response_data1)); |
| 2104 EXPECT_EQ("This server is borked.", response_data1); |
| 2105 // Deleting the transaction attempts to release the socket back into the |
| 2106 // socket pool. |
| 2107 trans1.reset(); |
| 2108 |
| 2109 HttpRequestInfo request2; |
| 2110 request2.method = "GET"; |
| 2111 request2.url = GURL("http://www.borked.com/foo"); |
| 2112 |
| 2113 scoped_ptr<HttpTransaction> trans2( |
| 2114 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2115 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); |
| 2116 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2117 |
| 2118 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); |
| 2119 ASSERT_TRUE(response2); |
| 2120 ASSERT_TRUE(response2->headers); |
| 2121 EXPECT_EQ(200, response2->headers->response_code()); |
| 2122 |
| 2123 std::string response_data2; |
| 2124 EXPECT_EQ(OK, ReadTransaction(trans2.get(), &response_data2)); |
| 2125 EXPECT_EQ("foo", response_data2); |
| 2126 } |
| 2127 |
| 2128 TEST_P(HttpNetworkTransactionTest, KeepAliveWithUnusedData3) { |
| 2129 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
| 2130 MockWrite data_writes1[] = { |
| 2131 MockWrite("GET / HTTP/1.1\r\n" |
| 2132 "Host: www.borked.com\r\n" |
| 2133 "Connection: keep-alive\r\n\r\n"), |
| 2134 }; |
| 2135 |
| 2136 MockRead data_reads1[] = { |
| 2137 MockRead("HTTP/1.1 200 OK\r\n" |
| 2138 "Connection: keep-alive\r\n" |
| 2139 "Transfer-Encoding: chunked\r\n\r\n"), |
| 2140 MockRead("16\r\nThis server is borked.\r\n"), |
| 2141 MockRead("0\r\n\r\nBonus data!"), |
| 2142 }; |
| 2143 |
| 2144 MockWrite data_writes2[] = { |
| 2145 MockWrite("GET /foo HTTP/1.1\r\n" |
| 2146 "Host: www.borked.com\r\n" |
| 2147 "Connection: keep-alive\r\n\r\n"), |
| 2148 }; |
| 2149 |
| 2150 MockRead data_reads2[] = { |
| 2151 MockRead("HTTP/1.1 200 OK\r\n" |
| 2152 "Content-Length: 3\r\n\r\n" |
| 2153 "foo"), |
| 2154 }; |
| 2155 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 2156 data_writes1, arraysize(data_writes1)); |
| 2157 session_deps_.socket_factory->AddSocketDataProvider(&data1); |
| 2158 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 2159 data_writes2, arraysize(data_writes2)); |
| 2160 session_deps_.socket_factory->AddSocketDataProvider(&data2); |
| 2161 |
| 2162 TestCompletionCallback callback; |
| 2163 HttpRequestInfo request1; |
| 2164 request1.method = "GET"; |
| 2165 request1.url = GURL("http://www.borked.com/"); |
| 2166 |
| 2167 scoped_ptr<HttpTransaction> trans1( |
| 2168 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2169 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); |
| 2170 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2171 |
| 2172 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); |
| 2173 ASSERT_TRUE(response1); |
| 2174 ASSERT_TRUE(response1->headers); |
| 2175 EXPECT_EQ(200, response1->headers->response_code()); |
| 2176 EXPECT_TRUE(response1->headers->IsKeepAlive()); |
| 2177 |
| 2178 std::string response_data1; |
| 2179 EXPECT_EQ(OK, ReadTransaction(trans1.get(), &response_data1)); |
| 2180 EXPECT_EQ("This server is borked.", response_data1); |
| 2181 // Deleting the transaction attempts to release the socket back into the |
| 2182 // socket pool. |
| 2183 trans1.reset(); |
| 2184 |
| 2185 HttpRequestInfo request2; |
| 2186 request2.method = "GET"; |
| 2187 request2.url = GURL("http://www.borked.com/foo"); |
| 2188 |
| 2189 scoped_ptr<HttpTransaction> trans2( |
| 2190 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2191 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); |
| 2192 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2193 |
| 2194 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); |
| 2195 ASSERT_TRUE(response2); |
| 2196 ASSERT_TRUE(response2->headers); |
| 2197 EXPECT_EQ(200, response2->headers->response_code()); |
| 2198 |
| 2199 std::string response_data2; |
| 2200 EXPECT_EQ(OK, ReadTransaction(trans2.get(), &response_data2)); |
| 2201 EXPECT_EQ("foo", response_data2); |
| 2202 } |
| 2203 |
| 2204 // This is a little different from the others - it tests the case that the |
| 2205 // HttpStreamParser doesn't know if there's extra data on a socket or not when |
| 2206 // the HttpNetworkTransaction is torn down, because the response body hasn't |
| 2207 // been read from yet, but the request goes through the HttpResponseBodyDrainer. |
| 2208 TEST_P(HttpNetworkTransactionTest, KeepAliveWithUnusedData4) { |
| 2209 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
| 2210 MockWrite data_writes1[] = { |
| 2211 MockWrite("GET / HTTP/1.1\r\n" |
| 2212 "Host: www.borked.com\r\n" |
| 2213 "Connection: keep-alive\r\n\r\n"), |
| 2214 }; |
| 2215 |
| 2216 MockRead data_reads1[] = { |
| 2217 MockRead("HTTP/1.1 200 OK\r\n" |
| 2218 "Connection: keep-alive\r\n" |
| 2219 "Transfer-Encoding: chunked\r\n\r\n"), |
| 2220 MockRead("16\r\nThis server is borked.\r\n"), |
| 2221 MockRead("0\r\n\r\nBonus data!"), |
| 2222 }; |
| 2223 |
| 2224 MockWrite data_writes2[] = { |
| 2225 MockWrite("GET /foo HTTP/1.1\r\n" |
| 2226 "Host: www.borked.com\r\n" |
| 2227 "Connection: keep-alive\r\n\r\n"), |
| 2228 }; |
| 2229 |
| 2230 MockRead data_reads2[] = { |
| 2231 MockRead("HTTP/1.1 200 OK\r\n" |
| 2232 "Content-Length: 3\r\n\r\n" |
| 2233 "foo"), |
| 2234 }; |
| 2235 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 2236 data_writes1, arraysize(data_writes1)); |
| 2237 session_deps_.socket_factory->AddSocketDataProvider(&data1); |
| 2238 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 2239 data_writes2, arraysize(data_writes2)); |
| 2240 session_deps_.socket_factory->AddSocketDataProvider(&data2); |
| 2241 |
| 2242 TestCompletionCallback callback; |
| 2243 HttpRequestInfo request1; |
| 2244 request1.method = "GET"; |
| 2245 request1.url = GURL("http://www.borked.com/"); |
| 2246 |
| 2247 scoped_ptr<HttpTransaction> trans1( |
| 2248 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2249 int rv = trans1->Start(&request1, callback.callback(), BoundNetLog()); |
| 2250 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2251 |
| 2252 const HttpResponseInfo* response1 = trans1->GetResponseInfo(); |
| 2253 ASSERT_TRUE(response1); |
| 2254 ASSERT_TRUE(response1->headers); |
| 2255 EXPECT_EQ(200, response1->headers->response_code()); |
| 2256 EXPECT_TRUE(response1->headers->IsKeepAlive()); |
| 2257 |
| 2258 // Deleting the transaction creates an HttpResponseBodyDrainer to read the |
| 2259 // response body. |
| 2260 trans1.reset(); |
| 2261 |
| 2262 // Let the HttpResponseBodyDrainer drain the socket. It should determine the |
| 2263 // socket can't be reused, rather than returning it to the socket pool. |
| 2264 base::RunLoop().RunUntilIdle(); |
| 2265 |
| 2266 HttpRequestInfo request2; |
| 2267 request2.method = "GET"; |
| 2268 request2.url = GURL("http://www.borked.com/foo"); |
| 2269 |
| 2270 scoped_ptr<HttpTransaction> trans2( |
| 2271 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| 2272 rv = trans2->Start(&request2, callback.callback(), BoundNetLog()); |
| 2273 EXPECT_EQ(OK, callback.GetResult(rv)); |
| 2274 |
| 2275 const HttpResponseInfo* response2 = trans2->GetResponseInfo(); |
| 2276 ASSERT_TRUE(response2); |
| 2277 ASSERT_TRUE(response2->headers); |
| 2278 EXPECT_EQ(200, response2->headers->response_code()); |
| 2279 |
| 2280 std::string response_data2; |
| 2281 EXPECT_EQ(OK, ReadTransaction(trans2.get(), &response_data2)); |
| 2282 EXPECT_EQ("foo", response_data2); |
| 2283 } |
| 2284 |
1974 // Test the request-challenge-retry sequence for basic auth. | 2285 // Test the request-challenge-retry sequence for basic auth. |
1975 // (basic auth is the easiest to mock, because it has no randomness). | 2286 // (basic auth is the easiest to mock, because it has no randomness). |
1976 TEST_P(HttpNetworkTransactionTest, BasicAuth) { | 2287 TEST_P(HttpNetworkTransactionTest, BasicAuth) { |
1977 HttpRequestInfo request; | 2288 HttpRequestInfo request; |
1978 request.method = "GET"; | 2289 request.method = "GET"; |
1979 request.url = GURL("http://www.example.org/"); | 2290 request.url = GURL("http://www.example.org/"); |
1980 request.load_flags = 0; | 2291 request.load_flags = 0; |
1981 | 2292 |
1982 TestNetLog log; | 2293 TestNetLog log; |
1983 session_deps_.net_log = &log; | 2294 session_deps_.net_log = &log; |
(...skipping 5090 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7074 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 7385 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
7075 scoped_ptr<HttpNetworkTransaction> trans( | 7386 scoped_ptr<HttpNetworkTransaction> trans( |
7076 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 7387 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
7077 | 7388 |
7078 // Setup some state (which we expect ResetStateForRestart() will clear). | 7389 // Setup some state (which we expect ResetStateForRestart() will clear). |
7079 trans->read_buf_ = new IOBuffer(15); | 7390 trans->read_buf_ = new IOBuffer(15); |
7080 trans->read_buf_len_ = 15; | 7391 trans->read_buf_len_ = 15; |
7081 trans->request_headers_.SetHeader("Authorization", "NTLM"); | 7392 trans->request_headers_.SetHeader("Authorization", "NTLM"); |
7082 | 7393 |
7083 // Setup state in response_ | 7394 // Setup state in response_ |
7084 HttpResponseInfo* response = &trans->response_; | 7395 HttpResponseInfo* response = trans->response_.get(); |
7085 response->auth_challenge = new AuthChallengeInfo(); | 7396 response->auth_challenge = new AuthChallengeInfo(); |
7086 response->ssl_info.cert_status = static_cast<CertStatus>(-1); // Nonsensical. | 7397 response->ssl_info.cert_status = static_cast<CertStatus>(-1); // Nonsensical. |
7087 response->response_time = base::Time::Now(); | 7398 response->response_time = base::Time::Now(); |
7088 response->was_cached = true; // (Wouldn't ever actually be true...) | 7399 response->was_cached = true; // (Wouldn't ever actually be true...) |
7089 | 7400 |
7090 { // Setup state for response_.vary_data | 7401 { // Setup state for response_.vary_data |
7091 HttpRequestInfo request; | 7402 HttpRequestInfo request; |
7092 std::string temp("HTTP/1.1 200 OK\nVary: foo, bar\n\n"); | 7403 std::string temp("HTTP/1.1 200 OK\nVary: foo, bar\n\n"); |
7093 std::replace(temp.begin(), temp.end(), '\n', '\0'); | 7404 std::replace(temp.begin(), temp.end(), '\n', '\0'); |
7094 scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(temp)); | 7405 scoped_refptr<HttpResponseHeaders> headers(new HttpResponseHeaders(temp)); |
(...skipping 7426 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14521 } | 14832 } |
14522 | 14833 |
14523 bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; } | 14834 bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; } |
14524 | 14835 |
14525 Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key, | 14836 Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key, |
14526 std::vector<uint8_t>* out) override { | 14837 std::vector<uint8_t>* out) override { |
14527 ADD_FAILURE(); | 14838 ADD_FAILURE(); |
14528 return ERR_NOT_IMPLEMENTED; | 14839 return ERR_NOT_IMPLEMENTED; |
14529 } | 14840 } |
14530 | 14841 |
14531 void Drain(HttpNetworkSession* session) override { ADD_FAILURE(); } | 14842 void Drain(HttpNetworkSession* session, |
| 14843 scoped_ptr<HttpResponseInfo> response_info) override { |
| 14844 ADD_FAILURE(); |
| 14845 } |
14532 | 14846 |
14533 void PopulateNetErrorDetails(NetErrorDetails* details) override { return; } | 14847 void PopulateNetErrorDetails(NetErrorDetails* details) override { return; } |
14534 | 14848 |
14535 void SetPriority(RequestPriority priority) override { priority_ = priority; } | 14849 void SetPriority(RequestPriority priority) override { priority_ = priority; } |
14536 | 14850 |
14537 UploadProgress GetUploadProgress() const override { return UploadProgress(); } | 14851 UploadProgress GetUploadProgress() const override { return UploadProgress(); } |
14538 | 14852 |
14539 HttpStream* RenewStreamForAuth() override { return NULL; } | 14853 HttpStream* RenewStreamForAuth() override { return NULL; } |
14540 | 14854 |
14541 private: | 14855 private: |
(...skipping 216 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14758 } | 15072 } |
14759 | 15073 |
14760 bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; } | 15074 bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; } |
14761 | 15075 |
14762 Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key, | 15076 Error GetSignedEKMForTokenBinding(crypto::ECPrivateKey* key, |
14763 std::vector<uint8_t>* out) override { | 15077 std::vector<uint8_t>* out) override { |
14764 ADD_FAILURE(); | 15078 ADD_FAILURE(); |
14765 return ERR_NOT_IMPLEMENTED; | 15079 return ERR_NOT_IMPLEMENTED; |
14766 } | 15080 } |
14767 | 15081 |
14768 void Drain(HttpNetworkSession* session) override { NOTREACHED(); } | 15082 void Drain(HttpNetworkSession* session, |
| 15083 scoped_ptr<HttpResponseInfo> response_info) override { |
| 15084 NOTREACHED(); |
| 15085 } |
14769 | 15086 |
14770 void PopulateNetErrorDetails(NetErrorDetails* details) override { return; } | 15087 void PopulateNetErrorDetails(NetErrorDetails* details) override { return; } |
14771 | 15088 |
14772 void SetPriority(RequestPriority priority) override { NOTREACHED(); } | 15089 void SetPriority(RequestPriority priority) override { NOTREACHED(); } |
14773 | 15090 |
14774 UploadProgress GetUploadProgress() const override { | 15091 UploadProgress GetUploadProgress() const override { |
14775 NOTREACHED(); | 15092 NOTREACHED(); |
14776 return UploadProgress(); | 15093 return UploadProgress(); |
14777 } | 15094 } |
14778 | 15095 |
(...skipping 1173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
15952 base::MessageLoop::current()->RunUntilIdle(); | 16269 base::MessageLoop::current()->RunUntilIdle(); |
15953 | 16270 |
15954 EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy); | 16271 EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy); |
15955 HttpRequestHeaders headers; | 16272 HttpRequestHeaders headers; |
15956 ASSERT_TRUE(trans.GetFullRequestHeaders(&headers)); | 16273 ASSERT_TRUE(trans.GetFullRequestHeaders(&headers)); |
15957 EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding)); | 16274 EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding)); |
15958 } | 16275 } |
15959 #endif // !defined(OS_IOS) | 16276 #endif // !defined(OS_IOS) |
15960 | 16277 |
15961 } // namespace net | 16278 } // namespace net |
OLD | NEW |