Home | History | Annotate | Download | only in nacl 
      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
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/test/nacl/pnacl_header_test.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/path_service.h"
      9 #include "base/test/scoped_path_override.h"
     10 #include "chrome/browser/ui/browser.h"
     11 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     12 #include "chrome/common/chrome_paths.h"
     13 #include "chrome/test/base/ui_test_utils.h"
     14 #include "chrome/test/nacl/nacl_browsertest_util.h"
     15 #include "content/public/browser/resource_dispatcher_host.h"
     16 #include "content/public/browser/web_contents.h"
     17 #include "net/test/embedded_test_server/embedded_test_server.h"
     18 #include "net/test/embedded_test_server/http_request.h"
     19 #include "net/test/embedded_test_server/http_response.h"
     20 #include "net/url_request/url_request.h"
     21 
     22 using net::test_server::BasicHttpResponse;
     23 using net::test_server::EmbeddedTestServer;
     24 using net::test_server::HttpRequest;
     25 using net::test_server::HttpResponse;
     26 
     27 void TestDispatcherHostDelegate::RequestBeginning(
     28     net::URLRequest* request,
     29     content::ResourceContext* resource_context,
     30     content::AppCacheService* appcache_service,
     31     content::ResourceType resource_type,
     32     ScopedVector<content::ResourceThrottle>* throttles) {
     33   // This checks the same condition as the one for PNaCl in
     34   // AppendComponentUpdaterThrottles.
     35   if (resource_type == content::RESOURCE_TYPE_OBJECT) {
     36     const net::HttpRequestHeaders& headers = request->extra_request_headers();
     37     std::string accept_headers;
     38     if (headers.GetHeader("Accept", &accept_headers)) {
     39       if (accept_headers.find("application/x-pnacl") != std::string::npos)
     40         found_pnacl_header_ = true;
     41     }
     42   }
     43 }
     44 
     45 PnaclHeaderTest::PnaclHeaderTest() : noncors_loads_(0), cors_loads_(0) {}
     46 
     47 PnaclHeaderTest::~PnaclHeaderTest() {}
     48 
     49 void PnaclHeaderTest::StartServer() {
     50   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     51 
     52   // For most requests, just serve files, but register a special test handler
     53   // that watches for the .pexe fetch also.
     54   base::FilePath test_data_dir;
     55   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
     56   embedded_test_server()->RegisterRequestHandler(
     57       base::Bind(&PnaclHeaderTest::WatchForPexeFetch, base::Unretained(this)));
     58   embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
     59 }
     60 
     61 void PnaclHeaderTest::RunLoadTest(const std::string& url,
     62                                   int expected_noncors,
     63                                   int expected_cors) {
     64   content::ResourceDispatcherHost::Get()->SetDelegate(&test_delegate_);
     65   StartServer();
     66   LoadTestMessageHandler handler;
     67   content::JavascriptTestObserver observer(
     68       browser()->tab_strip_model()->GetActiveWebContents(),
     69       &handler);
     70 
     71   // Make sure this is able to do a pexe fetch, even without access
     72   // to the PNaCl component files (make DIR_PNACL_COMPONENT empty).
     73   // The pexe fetch that is done with special headers must be able to
     74   // start before the component files are on disk. This is because it
     75   // is the pexe fetch that helps trigger an on-demand installation
     76   // which installs the files to disk (if that hasn't already happened
     77   // in the background).
     78   base::ScopedPathOverride component_dir(chrome::DIR_PNACL_COMPONENT);
     79 
     80   ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(url));
     81 
     82   // Wait until the NMF and pexe are also loaded, not just the HTML.
     83   // Do this by waiting till the LoadTestMessageHandler responds.
     84   EXPECT_TRUE(observer.Run()) << handler.error_message();
     85 
     86   // Now check the expectations.
     87   EXPECT_TRUE(handler.test_passed()) << "Test failed.";
     88   EXPECT_EQ(expected_noncors, noncors_loads_);
     89   EXPECT_EQ(expected_cors, cors_loads_);
     90 
     91   content::ResourceDispatcherHost::Get()->SetDelegate(NULL);
     92 }
     93 
     94 scoped_ptr<HttpResponse> PnaclHeaderTest::WatchForPexeFetch(
     95     const HttpRequest& request) {
     96   // Avoid favicon.ico warning by giving it a dummy icon.
     97   if (request.relative_url.find("favicon.ico") != std::string::npos) {
     98     scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
     99     http_response->set_code(net::HTTP_OK);
    100     http_response->set_content("");
    101     http_response->set_content_type("application/octet-stream");
    102     return http_response.PassAs<HttpResponse>();
    103   }
    104 
    105   // Skip other non-pexe files and let ServeFilesFromDirectory handle it.
    106   GURL absolute_url = embedded_test_server()->GetURL(request.relative_url);
    107   if (absolute_url.path().find(".pexe") == std::string::npos)
    108     return scoped_ptr<HttpResponse>();
    109 
    110   // For pexe files, check for the special Accept header,
    111   // along with the expected ResourceType of the URL request.
    112   EXPECT_NE(0U, request.headers.count("Accept"));
    113   std::map<std::string, std::string>::const_iterator it =
    114       request.headers.find("Accept");
    115   EXPECT_NE(std::string::npos, it->second.find("application/x-pnacl"));
    116   EXPECT_NE(std::string::npos, it->second.find("*/*"));
    117   EXPECT_TRUE(test_delegate_.found_pnacl_header());
    118 
    119   // Also make sure that other headers like CORS-related headers
    120   // are preserved when injecting the special Accept header.
    121   if (absolute_url.path().find("cors") == std::string::npos) {
    122     EXPECT_EQ(0U, request.headers.count("Origin"));
    123     noncors_loads_ += 1;
    124   } else {
    125     EXPECT_EQ(1U, request.headers.count("Origin"));
    126     cors_loads_ += 1;
    127   }
    128 
    129   // After checking the header, just return a 404. We don't need to actually
    130   // compile and stopping with a 404 is faster.
    131   scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
    132   http_response->set_code(net::HTTP_NOT_FOUND);
    133   http_response->set_content("PEXE ... not found");
    134   http_response->set_content_type("application/octet-stream");
    135   return http_response.PassAs<HttpResponse>();
    136 }
    137 
    138 IN_PROC_BROWSER_TEST_F(PnaclHeaderTest, TestHasPnaclHeader) {
    139   // Load 2 pexes, one same origin and one cross orgin.
    140   RunLoadTest("/nacl/pnacl_request_header/pnacl_request_header.html", 1, 1);
    141 }
    142