content/browser/loader/async_revalidation_manager_browsertest.cc

// Copyright 2015 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 <string>
#include <utility>

#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/run_loop.h"
#include "base/strings/string16.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/content_browser_test.h"
#include "content/public/test/content_browser_test_utils.h"
#include "content/shell/browser/shell.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "net/test/embedded_test_server/http_request.h"
#include "net/test/embedded_test_server/http_response.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"

namespace content {

namespace {

using net::test_server::HttpResponse;
using net::test_server::HttpRequest;
using net::test_server::BasicHttpResponse;

const char kCountedHtmlPath[] = "/counted.html";
const char kCookieHtmlPath[] = "/cookie.html";

class AsyncRevalidationManagerBrowserTest : public ContentBrowserTest {
 protected:
  AsyncRevalidationManagerBrowserTest() {}
  ~AsyncRevalidationManagerBrowserTest() override {}

  void SetUp() override {
    ASSERT_TRUE(embedded_test_server()->InitializeAndListen());
    ContentBrowserTest::SetUp();
  }

  void SetUpOnMainThread() override {
    embedded_test_server()->StartAcceptingConnections();
  }

  void SetUpCommandLine(base::CommandLine* command_line) override {
    command_line->AppendSwitch("enable-stale-while-revalidate");
  }

  base::RunLoop* run_loop() { return &run_loop_; }
  int requests_counted() const { return requests_counted_; }

  // This method lacks diagnostics for the failure case because TitleWatcher
  // will just wait until the test times out if |expected_title| does not
  // appear.
  bool TitleBecomes(const GURL& url, const std::string& expected_title) {
    base::string16 expected_title16(base::ASCIIToUTF16(expected_title));
    TitleWatcher title_watcher(shell()->web_contents(), expected_title16);
    NavigateToURL(shell(), url);
    return title_watcher.WaitAndGetTitle() == expected_title16;
  }

  void RegisterCountingRequestHandler() {
    embedded_test_server()->RegisterRequestHandler(base::Bind(
        &AsyncRevalidationManagerBrowserTest::CountingRequestHandler, this));
  }

  void RegisterCookieRequestHandler() {
    embedded_test_server()->RegisterRequestHandler(base::Bind(
        &AsyncRevalidationManagerBrowserTest::CookieRequestHandler, this));
  }

 private:
  // A request handler which increases the number in the title tag on every
  // request.
  scoped_ptr<HttpResponse> CountingRequestHandler(const HttpRequest& request) {
    if (request.relative_url != kCountedHtmlPath)
      return nullptr;

    int version = ++requests_counted_;

    scoped_ptr<BasicHttpResponse> http_response(StaleWhileRevalidateHeaders());
    http_response->set_content(
        base::StringPrintf("<title>Version %d</title>", version));

    // The second time this handler is run is the async revalidation. Tests can
    // use this for synchronisation.
    if (version == 2)
      run_loop_.Quit();
    return std::move(http_response);
  }

  // A request handler which increases a cookie value on every request.
  scoped_ptr<HttpResponse> CookieRequestHandler(const HttpRequest& request) {
    static const char kHtml[] =
        "<script>\n"
        "var intervalId;\n"
        "function checkCookie() {\n"
        "  if (document.cookie.search(/version=2/) != -1) {\n"
        "    clearInterval(intervalId);\n"
        "    document.title = \"PASS\";\n"
        "  }\n"
        "}\n"
        "intervalId = setInterval(checkCookie, 10);\n"
        "</script>\n"
        "<title>Loaded</title>\n";

    if (request.relative_url != kCookieHtmlPath)
      return nullptr;

    int version = ++requests_counted_;

    scoped_ptr<BasicHttpResponse> http_response(StaleWhileRevalidateHeaders());
    http_response->AddCustomHeader("Set-Cookie",
                                   base::StringPrintf("version=%d", version));
    http_response->set_content(kHtml);

    return std::move(http_response);
  }

  // Generate the standard response headers common to all request handlers.
  scoped_ptr<BasicHttpResponse> StaleWhileRevalidateHeaders() {
    scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
    http_response->set_code(net::HTTP_OK);
    http_response->set_content_type("text/html; charset=utf-8");
    http_response->AddCustomHeader("Cache-Control",
                                   "max-age=0, stale-while-revalidate=86400");
    // A validator is needed for revalidations, and hence
    // stale-while-revalidate, to work.
    std::string etag = base::StringPrintf(
        "\"AsyncRevalidationManagerBrowserTest%d\"", requests_counted_);
    http_response->AddCustomHeader("ETag", etag);
    return http_response;
  }

  base::RunLoop run_loop_;
  int requests_counted_ = 0;

  DISALLOW_COPY_AND_ASSIGN(AsyncRevalidationManagerBrowserTest);
};

// Verify that the "Cache-Control: stale-while-revalidate" directive correctly
// triggers an async revalidation.
IN_PROC_BROWSER_TEST_F(AsyncRevalidationManagerBrowserTest,
                       StaleWhileRevalidateIsApplied) {
  RegisterCountingRequestHandler();
  GURL url(embedded_test_server()->GetURL(kCountedHtmlPath));

  EXPECT_TRUE(TitleBecomes(url, "Version 1"));

  // The first request happens synchronously.
  EXPECT_EQ(1, requests_counted());

  // Force the renderer to be destroyed so that the Blink cache doesn't
  // interfere with the result.
  NavigateToURL(shell(), GURL("about:blank"));

  // Load the page again. We should get the stale version from the cache.
  EXPECT_TRUE(TitleBecomes(url, "Version 1"));

  // Wait for the async revalidation to complete.
  run_loop()->Run();
  EXPECT_EQ(2, requests_counted());
}

// The fresh cache entry must become visible once the async revalidation request
// has been sent.
IN_PROC_BROWSER_TEST_F(AsyncRevalidationManagerBrowserTest, CacheIsUpdated) {
  using base::ASCIIToUTF16;
  RegisterCountingRequestHandler();
  GURL url(embedded_test_server()->GetURL(kCountedHtmlPath));

  EXPECT_TRUE(TitleBecomes(url, "Version 1"));

  // Reset the renderer cache.
  NavigateToURL(shell(), GURL("about:blank"));

  // Load the page again. We should get the stale version from the cache.
  EXPECT_TRUE(TitleBecomes(url, "Version 1"));

  // Wait for the async revalidation request to be processed by the
  // EmbeddedTestServer.
  run_loop()->Run();

  // Reset the renderer cache.
  NavigateToURL(shell(), GURL("about:blank"));

  // Since the async revalidation request has been sent, the cache can no
  // longer return the stale contents.
  EXPECT_TRUE(TitleBecomes(url, "Version 2"));
}

// When the asynchronous revalidation arrives, any cookies it contains must be
// applied immediately.
IN_PROC_BROWSER_TEST_F(AsyncRevalidationManagerBrowserTest,
                       CookieSetAsynchronously) {
  RegisterCookieRequestHandler();
  GURL url(embedded_test_server()->GetURL(kCookieHtmlPath));

  // Set cookie to version=1
  NavigateToURL(shell(), url);

  // Reset render cache.
  NavigateToURL(shell(), GURL("about:blank"));

  // The page will load from the cache, then when the async revalidation
  // completes the cookie will update.
  EXPECT_TRUE(TitleBecomes(url, "PASS"));
}

}  // namespace

}  // namespace content