Remove memory cache from system URLRequestContext.

chrome/browser/io_thread_browsertest.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/io_thread.h"
 
 #include <memory>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 41 matching lines @@
   }
 
   void WaitForCompletion() { run_loop_.Run(); }
 
  private:
   base::RunLoop run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLFetcherDelegate);
 };
 
-class IOThreadPacTest : public InProcessBrowserTest {
+class IOThreadBrowserTest : public InProcessBrowserTest {
  public:
-  IOThreadPacTest() {}
-  ~IOThreadPacTest() override {}
+  IOThreadBrowserTest() {}
+  ~IOThreadBrowserTest() override {}
 
   void SetUp() override {
     // Must start listening (And get a port for the proxy) before calling
-    // SetUp().
+    // SetUp(). Use two phase EmbeddedTestServer setup for proxy tests.
     ASSERT_TRUE(embedded_test_server()->InitializeAndListen());
     InProcessBrowserTest::SetUp();
   }
 
   void SetUpOnMainThread() override {
     embedded_test_server()->StartAcceptingConnections();
 
     InProcessBrowserTest::SetUpOnMainThread();
   }
 
   void TearDown() override {
     // Need to stop this before |connection_listener_| is destroyed.
     EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
     InProcessBrowserTest::TearDown();
   }
 };
 
-class IOThreadPacTestWithHangingRequest : public IOThreadPacTest {
+// Make sure that the system URLRequestContext does not cache responses. Main
+// reason for this test is that caching requires memory, so this guards against
+// accidentally hooking up a cache.
+IN_PROC_BROWSER_TEST_F(IOThreadBrowserTest, NoCache) {
+  GURL cacheable_url = embedded_test_server()->GetURL("/cachetime");
+  // Request a cacheable resource. Request should succeed.
+  TestURLFetcherDelegate fetcher_delegate;
+  std::unique_ptr<net::URLFetcher> fetcher = net::URLFetcher::Create(
+      cacheable_url, net::URLFetcher::GET, &fetcher_delegate);
+  fetcher->SetRequestContext(
+      g_browser_process->io_thread()->system_url_request_context_getter());
+  fetcher->Start();
+  fetcher_delegate.WaitForCompletion();
+  EXPECT_EQ(200, fetcher->GetResponseCode());
+
+  // Shut down server and re-request resource.  Request should fail.
+  TestURLFetcherDelegate failed_fetcher_delegate;
+  EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
+  fetcher = net::URLFetcher::Create(cacheable_url, net::URLFetcher::GET,
+                                    &failed_fetcher_delegate);
+  fetcher->SetRequestContext(
+      g_browser_process->io_thread()->system_url_request_context_getter());
+  fetcher->Start();
+  failed_fetcher_delegate.WaitForCompletion();
+  EXPECT_FALSE(fetcher->GetStatus().is_success());
+  EXPECT_EQ(net::ERR_CONNECTION_REFUSED, fetcher->GetStatus().error());
+}
+
+class IOThreadBrowserTestWithHangingPacRequest : public IOThreadBrowserTest {
  public:
-  IOThreadPacTestWithHangingRequest() {}
-  ~IOThreadPacTestWithHangingRequest() override {}
+  IOThreadBrowserTestWithHangingPacRequest() {}
+  ~IOThreadBrowserTestWithHangingPacRequest() override {}
 
   void SetUpOnMainThread() override {
     // This must be created after the main message loop has been set up.
     // Waits for one connection.  Additional connections are fine.
     connection_listener_ =
         base::MakeUnique<net::test_server::SimpleConnectionListener>(
             1, net::test_server::SimpleConnectionListener::
                    ALLOW_ADDITIONAL_CONNECTIONS);
 
     embedded_test_server()->SetConnectionListener(connection_listener_.get());
 
-    IOThreadPacTest::SetUpOnMainThread();
+    IOThreadBrowserTest::SetUpOnMainThread();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitchASCII(
         switches::kProxyPacUrl, embedded_test_server()->GetURL("/hung").spec());
   }
 
  protected:
   std::unique_ptr<net::test_server::SimpleConnectionListener>
       connection_listener_;
 };
 
 // Make sure that the SystemURLRequestContext is shut down correctly when
 // there's an in-progress PAC script fetch.
-IN_PROC_BROWSER_TEST_F(IOThreadPacTestWithHangingRequest, Shutdown) {
+IN_PROC_BROWSER_TEST_F(IOThreadBrowserTestWithHangingPacRequest, Shutdown) {
   // Request that should hang while trying to request the PAC script.
   // Enough requests are created on startup that this probably isn't needed, but
   // best to be safe.
   HangingURLFetcherDelegate hanging_fetcher_delegate;
   std::unique_ptr<net::URLFetcher> hanging_fetcher = net::URLFetcher::Create(
       GURL("http://blah/"), net::URLFetcher::GET, &hanging_fetcher_delegate);
   hanging_fetcher->SetRequestContext(
       g_browser_process->io_thread()->system_url_request_context_getter());
   hanging_fetcher->Start();
 
   connection_listener_->WaitForConnections();
 }
 
-class IOThreadPacTestWithFileURL : public IOThreadPacTest {
+class IOThreadBrowserTestWithPacFileURL : public IOThreadBrowserTest {
  public:
-  IOThreadPacTestWithFileURL() { EXPECT_TRUE(temp_dir_.CreateUniqueTempDir()); }
+  IOThreadBrowserTestWithPacFileURL() {
+    EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
+  }
 
-  ~IOThreadPacTestWithFileURL() override {}
+  ~IOThreadBrowserTestWithPacFileURL() override {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     base::FilePath pac_file_path;
     ASSERT_TRUE(
         base::CreateTemporaryFileInDir(temp_dir_.GetPath(), &pac_file_path));
 
     std::string pac_script = base::StringPrintf(
         "function FindProxyForURL(url, host){ return 'PROXY %s;'; }",
         net::HostPortPair::FromURL(embedded_test_server()->base_url())
             .ToString()
             .c_str());
     ASSERT_EQ(
         static_cast<int>(pac_script.size()),
         base::WriteFile(pac_file_path, pac_script.c_str(), pac_script.size()));
 
     command_line->AppendSwitchASCII(
         switches::kProxyPacUrl, net::FilePathToFileURL(pac_file_path).spec());
   }
 
  protected:
   base::ScopedTempDir temp_dir_;
 };
 
 // Make sure the system URLRequestContext can hadle fetching PAC scripts from
 // file URLs.
-IN_PROC_BROWSER_TEST_F(IOThreadPacTestWithFileURL, FilePac) {
+IN_PROC_BROWSER_TEST_F(IOThreadBrowserTestWithPacFileURL, FilePac) {
   TestURLFetcherDelegate fetcher_delegate;
   std::unique_ptr<net::URLFetcher> fetcher =
       net::URLFetcher::Create(GURL("http://foo:12345/echoheader?Foo"),
                               net::URLFetcher::GET, &fetcher_delegate);
   fetcher->AddExtraRequestHeader("Foo: Bar");
   fetcher->SetRequestContext(
       g_browser_process->io_thread()->system_url_request_context_getter());
   fetcher->Start();
   fetcher_delegate.WaitForCompletion();
   EXPECT_EQ(200, fetcher->GetResponseCode());
   std::string response;
   ASSERT_TRUE(fetcher->GetResponseAsString(&response));
   EXPECT_EQ("Bar", response);
 }
 
 }  // namespace