Server push cancellation: add a finch trial parameter

net/url_request/url_request_quic_unittest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_delegate.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mapped_host_resolver.h"
 #include "net/dns/mock_host_resolver.h"
+#include "net/log/net_log_event_type.h"
+#include "net/log/test_net_log.h"
+#include "net/log/test_net_log_entry.h"
 #include "net/quic/chromium/crypto/proof_source_chromium.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
 #include "net/tools/quic/quic_http_response_cache.h"
 #include "net/tools/quic/quic_simple_server.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 29 matching lines @@
     verify_result.verified_cert = ImportCertFromFile(
         GetTestCertsDirectory(), "quic_test_ecc.example.com.crt");
     cert_verifier_.AddResultForCertAndHost(verify_result.verified_cert.get(),
                                            "test.example.com", verify_result,
                                            OK);
     // To simplify the test, and avoid the race with the HTTP request, we force
     // QUIC for these requests.
     params->origins_to_force_quic_on.insert(HostPortPair(kTestServerHost, 443));
     params->cert_verifier = &cert_verifier_;
     params->enable_quic = true;
+    params->enable_server_push_cancellation = true;
     context_->set_host_resolver(host_resolver_.get());
     context_->set_http_network_session_params(std::move(params));
     context_->set_cert_verifier(&cert_verifier_);
+    context_->set_net_log(&net_log_);
   }
 
   void TearDown() override {
     if (server_)
       server_->Shutdown();
   }
 
   // Sets a NetworkDelegate to use for |context_|. Must be done before Init().
   void SetNetworkDelegate(NetworkDelegate* network_delegate) {
     context_->set_network_delegate(network_delegate);
   }
 
   // Initializes the TestURLRequestContext |context_|.
   void Init() { context_->Init(); }
 
   std::unique_ptr<URLRequest> CreateRequest(const GURL& url,
                                             RequestPriority priority,
                                             URLRequest::Delegate* delegate) {
     return context_->CreateRequest(url, priority, delegate);
   }
 
+  void ExtractNetLog(NetLogEventType type,
+                     TestNetLogEntry::List* entry_list) const {
+    net::TestNetLogEntry::List entries;
+    net_log_.GetEntries(&entries);
+
+    for (const auto& entry : entries) {
+      if (entry.type == type)
+        entry_list->push_back(entry);
+    }
+  }
+
  private:
   void StartQuicServer() {
     // Set up in-memory cache.
     response_cache_.AddSimpleResponse(kTestServerHost, kHelloPath, kHelloStatus,
                                       kHelloBodyValue);
+    response_cache_.InitializeFromDirectory(ServerPushCacheDirectory());
     net::QuicConfig config;
     // Set up server certs.
     std::unique_ptr<net::ProofSourceChromium> proof_source(
         new net::ProofSourceChromium());
     base::FilePath directory = GetTestCertsDirectory();
     CHECK(proof_source->Initialize(
         directory.Append(FILE_PATH_LITERAL("quic_test.example.com.crt")),
         directory.Append(FILE_PATH_LITERAL("quic_test.example.com.key.pkcs8")),
         directory.Append(FILE_PATH_LITERAL("quic_test.example.com.key.sct"))));
     server_.reset(new QuicSimpleServer(
         test::crypto_test_utils::ProofSourceForTesting(), config,
         net::QuicCryptoServerConfig::ConfigOptions(), AllSupportedVersions(),
         &response_cache_));
     int rv = server_->Listen(
         net::IPEndPoint(net::IPAddress::IPv4AllZeros(), kTestServerPort));
     EXPECT_GE(rv, 0) << "Quic server fails to start";
 
     std::unique_ptr<MockHostResolver> resolver(new MockHostResolver());
     resolver->rules()->AddRule("test.example.com", "127.0.0.1");
     host_resolver_.reset(new MappedHostResolver(std::move(resolver)));
     // Use a mapped host resolver so that request for test.example.com
     // reach the server running on localhost.
     std::string map_rule = "MAP test.example.com test.example.com:" +
                            base::IntToString(server_->server_address().port());
     EXPECT_TRUE(host_resolver_->AddRuleFromString(map_rule));
   }
 
+  std::string ServerPushCacheDirectory() {
+    base::FilePath path;
+    PathService::Get(base::DIR_SOURCE_ROOT, &path);
+    path = path.AppendASCII("net").AppendASCII("data").AppendASCII(
+        "quic_http_response_cache_data_with_push");
+    // The file path is known to be an ascii string.
+    return path.MaybeAsASCII();
+  }
+
   std::unique_ptr<MappedHostResolver> host_resolver_;
   std::unique_ptr<QuicSimpleServer> server_;
   std::unique_ptr<TestURLRequestContext> context_;
+  TestNetLog net_log_;
   QuicHttpResponseCache response_cache_;
   MockCertVerifier cert_verifier_;
 };
 
 // A URLRequest::Delegate that checks LoadTimingInfo when response headers are
 // received.
 class CheckLoadTimingDelegate : public TestDelegate {
  public:
   CheckLoadTimingDelegate(bool session_reused)
       : session_reused_(session_reused) {}
@@ skipping 68 matching lines @@
       CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_EQ(kHelloBodyValue, delegate.data_received());
 }
 
+TEST_F(URLRequestQuicTest, CancelPushIfCached) {

[Zhongyi Shi, 2017/02/16 07:39:50]

Currently the server push cancellation status is verified through the NetLogs on
the client, which is similar to the manual testing I have done before. Let me
know, if we have any better alternatives to verify.

[Ryan Hamilton, 2017/02/16 15:18:08]

One idea might be for the QUIC server to expose the number of requests it has
handled. So after each request in complete in the client, you could check the
server's count to see if it has moved as expected. It could also expose a reset
stream count as well.

+  base::RunLoop run_loop;
+  WaitForCompletionNetworkDelegate network_delegate(
+      run_loop.QuitClosure(), /*num_expected_requests=*/2);
+  SetNetworkDelegate(&network_delegate);
+
+  Init();
+  {
+    // Send a request to the pushed url: /kitten-1.jpg to pull the resource into
+    // cache.
+    CheckLoadTimingDelegate delegate(false);
+    std::string url =
+        base::StringPrintf("https://%s%s", kTestServerHost, "/kitten-1.jpg");
+    std::unique_ptr<URLRequest> request =
+        CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
+
+    request->Start();
+    ASSERT_TRUE(request->is_pending());
+    base::RunLoop().Run();
+
+    EXPECT_TRUE(request->status().is_success());
+  }
+
+  // Send a request to /index2.html which pushes /kitten-1.jpg and /favicon.ico.
+  // Should cancel push for /kitten-1.jpg.
+  CheckLoadTimingDelegate delegate(true);
+  std::string url =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/index2.html");
+  std::unique_ptr<URLRequest> request =
+      CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
+
+  request->Start();
+  ASSERT_TRUE(request->is_pending());
+  base::RunLoop().Run();
+
+  // Extract net logs to verify push lookup transactions.
+  net::TestNetLogEntry::List entries;
+  ExtractNetLog(NetLogEventType::SERVER_PUSH_LOOKUP_TRANSACTION, &entries);
+
+  EXPECT_EQ(4u, entries.size());
+
+  std::string value;
+  int net_error;
+  std::string push_url_1 =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/kitten-1.jpg");
+  std::string push_url_2 =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/favicon.ico");
+
+  EXPECT_TRUE(entries[0].GetStringValue("push_url", &value));
+  EXPECT_EQ(value, push_url_1);
+  // No net error code for this lookup transaction, the push is found.
+  EXPECT_FALSE(entries[1].GetIntegerValue("net_error", &net_error));
+
+  EXPECT_TRUE(entries[2].GetStringValue("push_url", &value));
+  EXPECT_EQ(value, push_url_2);
+  // Net error code -400 is found for this lookup transaction, the push is not
+  // found in the cache.
+  EXPECT_TRUE(entries[3].GetIntegerValue("net_error", &net_error));
+  EXPECT_EQ(net_error, -400);
+
+  EXPECT_TRUE(request->status().is_success());
+}
+
+TEST_F(URLRequestQuicTest, CancelPushIfCached2) {
+  base::RunLoop run_loop;
+  WaitForCompletionNetworkDelegate network_delegate(
+      run_loop.QuitClosure(), /*num_expected_requests=*/3);
+  SetNetworkDelegate(&network_delegate);
+
+  Init();
+  {
+    // Send a request to the pushed url: /kitten-1.jpg to pull the resource into
+    // cache.
+    CheckLoadTimingDelegate delegate(false);
+    std::string url =
+        base::StringPrintf("https://%s%s", kTestServerHost, "/kitten-1.jpg");
+    std::unique_ptr<URLRequest> request =
+        CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
+
+    request->Start();
+    ASSERT_TRUE(request->is_pending());
+    base::RunLoop().Run();
+
+    EXPECT_TRUE(request->status().is_success());
+    EXPECT_NE(network_delegate.total_network_bytes_sent(), 0u);
+  }
+
+  {
+    // Send a request to the pushed url: /favicon.ico to pull the resource into
+    // cache.
+    CheckLoadTimingDelegate delegate(true);
+    std::string url =
+        base::StringPrintf("https://%s%s", kTestServerHost, "/favicon.ico");
+    std::unique_ptr<URLRequest> request =
+        CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
+
+    request->Start();
+    ASSERT_TRUE(request->is_pending());
+    base::RunLoop().Run();
+
+    EXPECT_TRUE(request->status().is_success());
+  }
+
+  // Send a request to /index2.html which pushes /kitten-1.jpg and /favicon.ico.
+  // Should cancel push for /kitten-1.jpg.
+  CheckLoadTimingDelegate delegate(true);
+  std::string url =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/index2.html");
+  std::unique_ptr<URLRequest> request =
+      CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
+
+  request->Start();
+  ASSERT_TRUE(request->is_pending());
+  base::RunLoop().Run();
+
+  // Extract net logs to verify push lookup transactions.
+  net::TestNetLogEntry::List entries;
+  ExtractNetLog(NetLogEventType::SERVER_PUSH_LOOKUP_TRANSACTION, &entries);
+
+  EXPECT_EQ(4u, entries.size());
+
+  std::string value;
+  int net_error;
+  std::string push_url_1 =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/kitten-1.jpg");
+  std::string push_url_2 =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/favicon.ico");
+
+  EXPECT_TRUE(entries[0].GetStringValue("push_url", &value));
+  EXPECT_EQ(value, push_url_1);
+  // No net error code for this lookup transaction, the push is found.
+  EXPECT_FALSE(entries[1].GetIntegerValue("net_error", &net_error));
+
+  EXPECT_TRUE(entries[2].GetStringValue("push_url", &value));
+  EXPECT_EQ(value, push_url_2);
+  // No net error code for this lookup transaction, the push is found.
+  EXPECT_FALSE(entries[3].GetIntegerValue("net_error", &net_error));
+
+  EXPECT_TRUE(request->status().is_success());
+}
+
+TEST_F(URLRequestQuicTest, DoNotCancelPushIfNotFoundInCache) {
+  base::RunLoop run_loop;
+  WaitForCompletionNetworkDelegate network_delegate(
+      run_loop.QuitClosure(), /*num_expected_requests=*/1);
+  SetNetworkDelegate(&network_delegate);
+
+  Init();
+  // Send a request to /index2.hmtl which pushes /kitten-1.jpg and /favicon.ico
+  // and shouldn't cancel any since neither is in cache.
+  CheckLoadTimingDelegate delegate(false);
+  std::string url =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/index2.html");
+  std::unique_ptr<URLRequest> request =
+      CreateRequest(GURL(url), DEFAULT_PRIORITY, &delegate);
+
+  request->Start();
+  ASSERT_TRUE(request->is_pending());
+  base::RunLoop().Run();
+
+  // Extract net logs to verify push lookup transactions.
+  net::TestNetLogEntry::List entries;
+  ExtractNetLog(NetLogEventType::SERVER_PUSH_LOOKUP_TRANSACTION, &entries);
+
+  EXPECT_EQ(4u, entries.size());
+
+  std::string value;
+  int net_error;
+  std::string push_url_1 =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/kitten-1.jpg");
+  std::string push_url_2 =
+      base::StringPrintf("https://%s%s", kTestServerHost, "/favicon.ico");
+
+  EXPECT_TRUE(entries[0].GetStringValue("push_url", &value));
+  EXPECT_EQ(value, push_url_1);
+  EXPECT_TRUE(entries[1].GetIntegerValue("net_error", &net_error));
+  EXPECT_EQ(net_error, -400);
+
+  EXPECT_TRUE(entries[2].GetStringValue("push_url", &value));
+  EXPECT_EQ(value, push_url_2);
+  EXPECT_TRUE(entries[3].GetIntegerValue("net_error", &net_error));
+  EXPECT_EQ(net_error, -400);
+
+  EXPECT_TRUE(request->status().is_success());
+}
+
 // Tests that if two requests use the same QUIC session, the second request
 // should not have |LoadTimingInfo::connect_timing|.
 TEST_F(URLRequestQuicTest, TestTwoRequests) {
   base::RunLoop run_loop;
   WaitForCompletionNetworkDelegate network_delegate(
       run_loop.QuitClosure(), /*num_expected_requests=*/2);
   SetNetworkDelegate(&network_delegate);
   Init();
   CheckLoadTimingDelegate delegate(false);
   delegate.set_quit_on_complete(false);
@@ skipping 12 matching lines @@
   ASSERT_TRUE(request2->is_pending());
   run_loop.Run();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_TRUE(request2->status().is_success());
   EXPECT_EQ(kHelloBodyValue, delegate.data_received());
   EXPECT_EQ(kHelloBodyValue, delegate2.data_received());
 }
 
 }  // namespace net