Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/http/http_network_layer.h"
      6 
      7 #include "base/basictypes.h"
      8 #include "base/strings/stringprintf.h"
      9 #include "net/base/net_log.h"
     10 #include "net/cert/mock_cert_verifier.h"
     11 #include "net/dns/mock_host_resolver.h"
     12 #include "net/http/http_network_session.h"
     13 #include "net/http/http_server_properties_impl.h"
     14 #include "net/http/http_transaction_test_util.h"
     15 #include "net/http/transport_security_state.h"
     16 #include "net/proxy/proxy_service.h"
     17 #include "net/socket/socket_test_util.h"
     18 #include "net/spdy/spdy_session_pool.h"
     19 #include "net/ssl/ssl_config_service_defaults.h"
     20 #include "testing/gtest/include/gtest/gtest.h"
     21 #include "testing/platform_test.h"
     22 
     23 namespace net {
     24 
     25 namespace {
     26 
     27 class HttpNetworkLayerTest : public PlatformTest {
     28  protected:
     29   HttpNetworkLayerTest() : ssl_config_service_(new SSLConfigServiceDefaults) {}
     30 
     31   virtual void SetUp() {
     32     ConfigureTestDependencies(ProxyService::CreateDirect());
     33   }
     34 
     35   void ConfigureTestDependencies(ProxyService* proxy_service) {
     36     cert_verifier_.reset(new MockCertVerifier);
     37     transport_security_state_.reset(new TransportSecurityState);
     38     proxy_service_.reset(proxy_service);
     39     HttpNetworkSession::Params session_params;
     40     session_params.client_socket_factory = &mock_socket_factory_;
     41     session_params.host_resolver = &host_resolver_;
     42     session_params.cert_verifier = cert_verifier_.get();
     43     session_params.transport_security_state = transport_security_state_.get();
     44     session_params.proxy_service = proxy_service_.get();
     45     session_params.ssl_config_service = ssl_config_service_.get();
     46     session_params.http_server_properties =
     47         http_server_properties_.GetWeakPtr();
     48     network_session_ = new HttpNetworkSession(session_params);
     49     factory_.reset(new HttpNetworkLayer(network_session_.get()));
     50   }
     51 
     52   void ExecuteRequestExpectingContentAndHeader(const std::string& method,
     53                                                const std::string& content,
     54                                                const std::string& header,
     55                                                const std::string& value) {
     56     TestCompletionCallback callback;
     57 
     58     HttpRequestInfo request_info;
     59     request_info.url = GURL("http://www.google.com/");
     60     request_info.method = method;
     61     request_info.load_flags = LOAD_NORMAL;
     62 
     63     scoped_ptr<HttpTransaction> trans;
     64     int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
     65     EXPECT_EQ(OK, rv);
     66 
     67     rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
     68     if (rv == ERR_IO_PENDING)
     69       rv = callback.WaitForResult();
     70     ASSERT_EQ(OK, rv);
     71 
     72     std::string contents;
     73     rv = ReadTransaction(trans.get(), &contents);
     74     EXPECT_EQ(OK, rv);
     75     EXPECT_EQ(content, contents);
     76 
     77     if (!header.empty()) {
     78       // We also have a server header here that isn't set by the proxy.
     79       EXPECT_TRUE(trans->GetResponseInfo()->headers->HasHeaderValue(
     80           header, value));
     81     }
     82   }
     83 
     84   // Check that |proxy_count| proxies are in the retry list.
     85   // These will be, in order, |bad_proxy| and |bad_proxy2|".
     86   void TestBadProxies(unsigned int proxy_count, const std::string& bad_proxy,
     87                       const std::string& bad_proxy2) {
     88     const ProxyRetryInfoMap& retry_info = proxy_service_->proxy_retry_info();
     89     ASSERT_EQ(proxy_count, retry_info.size());
     90     if (proxy_count > 0)
     91       ASSERT_TRUE(retry_info.find(bad_proxy) != retry_info.end());
     92     if (proxy_count > 1)
     93       ASSERT_TRUE(retry_info.find(bad_proxy2) != retry_info.end());
     94   }
     95 
     96   // Simulates a request through a proxy which returns a bypass, which is then
     97   // retried through a second proxy that doesn't bypass.
     98   // Checks that the expected requests were issued, the expected content was
     99   // received, and the first proxy |bad_proxy| was marked as bad.
    100   void TestProxyFallback(const std::string& bad_proxy) {
    101     MockRead data_reads[] = {
    102       MockRead("HTTP/1.1 200 OK\r\n"
    103                "Chrome-Proxy: bypass=0\r\n\r\n"),
    104       MockRead("Bypass message"),
    105       MockRead(SYNCHRONOUS, OK),
    106     };
    107     TestProxyFallbackWithMockReads(bad_proxy, "", data_reads,
    108                                    arraysize(data_reads), 1u);
    109   }
    110 
    111   void TestProxyFallbackWithMockReads(const std::string& bad_proxy,
    112                                       const std::string& bad_proxy2,
    113                                       MockRead data_reads[],
    114                                       int data_reads_size,
    115                                       unsigned int expected_retry_info_size) {
    116     TestProxyFallbackByMethodWithMockReads(bad_proxy, bad_proxy2, data_reads,
    117                                            data_reads_size, "GET", "content",
    118                                            true, expected_retry_info_size);
    119   }
    120 
    121   void TestProxyFallbackByMethodWithMockReads(
    122       const std::string& bad_proxy,
    123       const std::string& bad_proxy2,
    124       MockRead data_reads[],
    125       int data_reads_size,
    126       std::string method,
    127       std::string content,
    128       bool retry_expected,
    129       unsigned int expected_retry_info_size) {
    130     std::string trailer =
    131         (method == "HEAD" || method == "PUT" || method == "POST") ?
    132         "Content-Length: 0\r\n\r\n" : "\r\n";
    133     std::string request =
    134         base::StringPrintf("%s http://www.google.com/ HTTP/1.1\r\n"
    135                            "Host: www.google.com\r\n"
    136                            "Proxy-Connection: keep-alive\r\n"
    137                            "%s", method.c_str(), trailer.c_str());
    138 
    139     MockWrite data_writes[] = {
    140       MockWrite(request.c_str()),
    141     };
    142 
    143     StaticSocketDataProvider data1(data_reads, data_reads_size,
    144                                   data_writes, arraysize(data_writes));
    145     mock_socket_factory_.AddSocketDataProvider(&data1);
    146 
    147     // Second data provider returns the expected content.
    148     MockRead data_reads2[3];
    149     size_t data_reads2_index = 0;
    150     data_reads2[data_reads2_index++] = MockRead("HTTP/1.0 200 OK\r\n"
    151                                                 "Server: not-proxy\r\n\r\n");
    152     if (!content.empty())
    153       data_reads2[data_reads2_index++] = MockRead(content.c_str());
    154     data_reads2[data_reads2_index++] = MockRead(SYNCHRONOUS, OK);
    155 
    156     MockWrite data_writes2[] = {
    157       MockWrite(request.c_str()),
    158     };
    159     StaticSocketDataProvider data2(data_reads2, data_reads2_index,
    160                                   data_writes2, arraysize(data_writes2));
    161     mock_socket_factory_.AddSocketDataProvider(&data2);
    162 
    163     // Expect that we get "content" and not "Bypass message", and that there's
    164     // a "not-proxy" "Server:" header in the final response.
    165     if (retry_expected) {
    166       ExecuteRequestExpectingContentAndHeader(method, content,
    167                                               "server", "not-proxy");
    168     } else {
    169       ExecuteRequestExpectingContentAndHeader(method, content, "", "");
    170     }
    171 
    172     // We should also observe the bad proxy in the retry list.
    173     TestBadProxies(expected_retry_info_size, bad_proxy, bad_proxy2);
    174   }
    175 
    176   // Simulates a request through a proxy which returns a bypass, which is then
    177   // retried through a direct connection to the origin site.
    178   // Checks that the expected requests were issued, the expected content was
    179   // received, and the proxy |bad_proxy| was marked as bad.
    180   void TestProxyFallbackToDirect(const std::string& bad_proxy) {
    181     MockRead data_reads[] = {
    182       MockRead("HTTP/1.1 200 OK\r\n"
    183                "Chrome-Proxy: bypass=0\r\n\r\n"),
    184       MockRead("Bypass message"),
    185       MockRead(SYNCHRONOUS, OK),
    186     };
    187     MockWrite data_writes[] = {
    188       MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
    189                 "Host: www.google.com\r\n"
    190                 "Proxy-Connection: keep-alive\r\n\r\n"),
    191     };
    192     StaticSocketDataProvider data1(data_reads, arraysize(data_reads),
    193                                   data_writes, arraysize(data_writes));
    194     mock_socket_factory_.AddSocketDataProvider(&data1);
    195 
    196     // Second data provider returns the expected content.
    197     MockRead data_reads2[] = {
    198       MockRead("HTTP/1.0 200 OK\r\n"
    199                "Server: not-proxy\r\n\r\n"),
    200       MockRead("content"),
    201       MockRead(SYNCHRONOUS, OK),
    202     };
    203     MockWrite data_writes2[] = {
    204       MockWrite("GET / HTTP/1.1\r\n"
    205                 "Host: www.google.com\r\n"
    206                 "Connection: keep-alive\r\n\r\n"),
    207     };
    208     StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
    209                                    data_writes2, arraysize(data_writes2));
    210     mock_socket_factory_.AddSocketDataProvider(&data2);
    211 
    212     // Expect that we get "content" and not "Bypass message", and that there's
    213     // a "not-proxy" "Server:" header in the final response.
    214     ExecuteRequestExpectingContentAndHeader("GET", "content",
    215                                             "server", "not-proxy");
    216 
    217     // We should also observe the bad proxy in the retry list.
    218     TestBadProxies(1u, bad_proxy, "");
    219   }
    220 
    221   // Simulates a request through a proxy which returns a bypass, under a
    222   // configuration where there is no valid bypass. |proxy_count| proxies
    223   // are expected to be configured.
    224   // Checks that the expected requests were issued, the bypass message was the
    225   // final received content,  and all proxies were marked as bad.
    226   void TestProxyFallbackFail(unsigned int proxy_count,
    227                              const std::string& bad_proxy,
    228                              const std::string& bad_proxy2) {
    229     MockRead data_reads[] = {
    230       MockRead("HTTP/1.1 200 OK\r\n"
    231                "Chrome-Proxy: bypass=0\r\n\r\n"),
    232       MockRead("Bypass message"),
    233       MockRead(SYNCHRONOUS, OK),
    234     };
    235     MockWrite data_writes[] = {
    236       MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
    237                 "Host: www.google.com\r\n"
    238                 "Proxy-Connection: keep-alive\r\n\r\n"),
    239     };
    240     StaticSocketDataProvider data1(data_reads, arraysize(data_reads),
    241                                    data_writes, arraysize(data_writes));
    242     StaticSocketDataProvider data2(data_reads, arraysize(data_reads),
    243                                    data_writes, arraysize(data_writes));
    244 
    245     mock_socket_factory_.AddSocketDataProvider(&data1);
    246     if (proxy_count > 1)
    247       mock_socket_factory_.AddSocketDataProvider(&data2);
    248 
    249     // Expect that we get "Bypass message", and not "content"..
    250     ExecuteRequestExpectingContentAndHeader("GET", "Bypass message", "", "");
    251 
    252     // We should also observe the bad proxy or proxies in the retry list.
    253     TestBadProxies(proxy_count, bad_proxy, bad_proxy2);
    254   }
    255 
    256   MockClientSocketFactory mock_socket_factory_;
    257   MockHostResolver host_resolver_;
    258   scoped_ptr<CertVerifier> cert_verifier_;
    259   scoped_ptr<TransportSecurityState> transport_security_state_;
    260   scoped_ptr<ProxyService> proxy_service_;
    261   const scoped_refptr<SSLConfigService> ssl_config_service_;
    262   scoped_refptr<HttpNetworkSession> network_session_;
    263   scoped_ptr<HttpNetworkLayer> factory_;
    264   HttpServerPropertiesImpl http_server_properties_;
    265 };
    266 
    267 TEST_F(HttpNetworkLayerTest, CreateAndDestroy) {
    268   scoped_ptr<HttpTransaction> trans;
    269   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    270   EXPECT_EQ(OK, rv);
    271   EXPECT_TRUE(trans.get() != NULL);
    272 }
    273 
    274 TEST_F(HttpNetworkLayerTest, Suspend) {
    275   scoped_ptr<HttpTransaction> trans;
    276   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    277   EXPECT_EQ(OK, rv);
    278 
    279   trans.reset();
    280 
    281   factory_->OnSuspend();
    282 
    283   rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    284   EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, rv);
    285 
    286   ASSERT_TRUE(trans == NULL);
    287 
    288   factory_->OnResume();
    289 
    290   rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    291   EXPECT_EQ(OK, rv);
    292 }
    293 
    294 TEST_F(HttpNetworkLayerTest, GET) {
    295   MockRead data_reads[] = {
    296     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
    297     MockRead("hello world"),
    298     MockRead(SYNCHRONOUS, OK),
    299   };
    300   MockWrite data_writes[] = {
    301     MockWrite("GET / HTTP/1.1\r\n"
    302               "Host: www.google.com\r\n"
    303               "Connection: keep-alive\r\n"
    304               "User-Agent: Foo/1.0\r\n\r\n"),
    305   };
    306   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
    307                                 data_writes, arraysize(data_writes));
    308   mock_socket_factory_.AddSocketDataProvider(&data);
    309 
    310   TestCompletionCallback callback;
    311 
    312   HttpRequestInfo request_info;
    313   request_info.url = GURL("http://www.google.com/");
    314   request_info.method = "GET";
    315   request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
    316                                        "Foo/1.0");
    317   request_info.load_flags = LOAD_NORMAL;
    318 
    319   scoped_ptr<HttpTransaction> trans;
    320   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    321   EXPECT_EQ(OK, rv);
    322 
    323   rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
    324   rv = callback.GetResult(rv);
    325   ASSERT_EQ(OK, rv);
    326 
    327   std::string contents;
    328   rv = ReadTransaction(trans.get(), &contents);
    329   EXPECT_EQ(OK, rv);
    330   EXPECT_EQ("hello world", contents);
    331 }
    332 
    333 TEST_F(HttpNetworkLayerTest, NetworkVerified) {
    334   MockRead data_reads[] = {
    335     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
    336     MockRead("hello world"),
    337     MockRead(SYNCHRONOUS, OK),
    338   };
    339   MockWrite data_writes[] = {
    340     MockWrite("GET / HTTP/1.1\r\n"
    341               "Host: www.google.com\r\n"
    342               "Connection: keep-alive\r\n"
    343               "User-Agent: Foo/1.0\r\n\r\n"),
    344   };
    345   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
    346                                 data_writes, arraysize(data_writes));
    347   mock_socket_factory_.AddSocketDataProvider(&data);
    348 
    349   TestCompletionCallback callback;
    350 
    351   HttpRequestInfo request_info;
    352   request_info.url = GURL("http://www.google.com/");
    353   request_info.method = "GET";
    354   request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
    355                                        "Foo/1.0");
    356   request_info.load_flags = LOAD_NORMAL;
    357 
    358   scoped_ptr<HttpTransaction> trans;
    359   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    360   EXPECT_EQ(OK, rv);
    361 
    362   rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
    363   ASSERT_EQ(OK, callback.GetResult(rv));
    364 
    365   EXPECT_TRUE(trans->GetResponseInfo()->network_accessed);
    366 }
    367 
    368 TEST_F(HttpNetworkLayerTest, NetworkUnVerified) {
    369   MockRead data_reads[] = {
    370     MockRead(ASYNC, ERR_CONNECTION_RESET),
    371   };
    372   MockWrite data_writes[] = {
    373     MockWrite("GET / HTTP/1.1\r\n"
    374               "Host: www.google.com\r\n"
    375               "Connection: keep-alive\r\n"
    376               "User-Agent: Foo/1.0\r\n\r\n"),
    377   };
    378   StaticSocketDataProvider data(data_reads, arraysize(data_reads),
    379                                 data_writes, arraysize(data_writes));
    380   mock_socket_factory_.AddSocketDataProvider(&data);
    381 
    382   TestCompletionCallback callback;
    383 
    384   HttpRequestInfo request_info;
    385   request_info.url = GURL("http://www.google.com/");
    386   request_info.method = "GET";
    387   request_info.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
    388                                        "Foo/1.0");
    389   request_info.load_flags = LOAD_NORMAL;
    390 
    391   scoped_ptr<HttpTransaction> trans;
    392   int rv = factory_->CreateTransaction(DEFAULT_PRIORITY, &trans);
    393   EXPECT_EQ(OK, rv);
    394 
    395   rv = trans->Start(&request_info, callback.callback(), BoundNetLog());
    396   ASSERT_EQ(ERR_CONNECTION_RESET, callback.GetResult(rv));
    397 
    398   // If the response info is null, that means that any consumer won't
    399   // see the network accessed bit set.
    400   EXPECT_EQ(NULL, trans->GetResponseInfo());
    401 }
    402 
    403 }  // namespace
    404 
    405 }  // namespace net
    406