stale-while-revalidate experimental implementation.

chrome/browser/io_thread.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 121 matching lines @@
 //  operators to do feature detection rather than UA-sniffing. As such, this
 //  trial runs continuously.
 //  * A SPDY/4 experiment, for SPDY/4 (aka HTTP/2) vs SPDY/3.1 comparisons and
 //  eventual SPDY/4 deployment.
 const char kSpdyFieldTrialName[] = "SPDY";
 const char kSpdyFieldTrialHoldbackGroupName[] = "SpdyDisabled";
 const char kSpdyFieldTrialHoldbackControlGroupName[] = "Control";
 const char kSpdyFieldTrialSpdy4GroupName[] = "Spdy4Enabled";
 const char kSpdyFieldTrialSpdy4ControlGroupName[] = "Spdy4Control";
 
+// Field trial for Cache-Control: stale-while-revalidate directive.
+const char kStaleWhileRevalidateFieldTrialName[] = "StaleWhileRevalidate";
+
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 void ObserveKeychainEvents() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   net::CertDatabase::GetInstance()->SetMessageLoopForKeychainEvents();
 }
 #endif
 
 // Used for the "system" URLRequestContext.
 class SystemURLRequestContext : public net::URLRequestContext {
  public:
@@ skipping 269 matching lines @@
 IOThread::Globals::
 SystemRequestContextLeakChecker::~SystemRequestContextLeakChecker() {
   if (globals_->system_request_context.get())
     globals_->system_request_context->AssertNoURLRequests();
 }
 
 IOThread::Globals::Globals()
     : system_request_context_leak_checker(this),
       enable_ssl_connect_job_waiting(false),
       ignore_certificate_errors(false),
+      use_stale_while_revalidate(false),
       testing_fixed_http_port(0),
       testing_fixed_https_port(0),
       enable_user_alternate_protocol_ports(false) {
 }
 
 IOThread::Globals::~Globals() {}
 
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
 IOThread::IOThread(
@@ skipping 253 matching lines @@
   if (command_line.HasSwitch(switches::kHostRules)) {
     TRACE_EVENT_BEGIN0("startup", "IOThread::InitAsync:SetRulesFromString");
     globals_->host_mapping_rules->SetRulesFromString(
         command_line.GetSwitchValueASCII(switches::kHostRules));
     TRACE_EVENT_END0("startup", "IOThread::InitAsync:SetRulesFromString");
   }
   if (command_line.HasSwitch(switches::kEnableSSLConnectJobWaiting))
     globals_->enable_ssl_connect_job_waiting = true;
   if (command_line.HasSwitch(switches::kIgnoreCertificateErrors))
     globals_->ignore_certificate_errors = true;
+  if (command_line.HasSwitch(switches::kEnableStaleWhileRevalidate))
+    globals_->use_stale_while_revalidate = true;
+  if (command_line.HasSwitch(switches::kDisableStaleWhileRevalidate))
+    globals_->use_stale_while_revalidate = false;
+  if (base::FieldTrialList::FindFullName(kStaleWhileRevalidateFieldTrialName) ==

[yhirano, 2014/08/26 07:52:01]

Can you tell me when and where the field trial is registered?

[Adam Rice, 2014/08/26 13:38:41]

I haven't registered it yet, so "when" is still in the future. It's generally
expected to have some metrics attached to a field trial, so I am going to add a
histogram for the total time spent on async request (that the use would have had
to wait for if they had been synchronous).

+      "Enabled")
+    globals_->use_stale_while_revalidate = true;
   if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
     globals_->testing_fixed_http_port =
         GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpPort);
   }
   if (command_line.HasSwitch(switches::kTestingFixedHttpsPort)) {
     globals_->testing_fixed_https_port =
         GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpsPort);
   }
   ConfigureQuic(command_line);
   if (command_line.HasSwitch(
@@ skipping 297 matching lines @@
   params->transport_security_state = globals.transport_security_state.get();
   params->ssl_config_service = globals.ssl_config_service.get();
   params->http_auth_handler_factory = globals.http_auth_handler_factory.get();
   params->http_server_properties =
       globals.http_server_properties->GetWeakPtr();
   params->network_delegate = globals.system_network_delegate.get();
   params->host_mapping_rules = globals.host_mapping_rules.get();
   params->enable_ssl_connect_job_waiting =
       globals.enable_ssl_connect_job_waiting;
   params->ignore_certificate_errors = globals.ignore_certificate_errors;
+  params->use_stale_while_revalidate = globals.use_stale_while_revalidate;
   params->testing_fixed_http_port = globals.testing_fixed_http_port;
   params->testing_fixed_https_port = globals.testing_fixed_https_port;
 
   globals.initial_max_spdy_concurrent_streams.CopyToIfSet(
       &params->spdy_initial_max_concurrent_streams);
   globals.force_spdy_single_domain.CopyToIfSet(
       &params->force_spdy_single_domain);
   globals.enable_spdy_compression.CopyToIfSet(
       &params->enable_spdy_compression);
   globals.enable_spdy_ping_based_connection_checking.CopyToIfSet(
@@ skipping 361 matching lines @@
   net::QuicVersionVector supported_versions = net::QuicSupportedVersions();
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == quic_version) {
       return version;
     }
   }
 
   return net::QUIC_VERSION_UNSUPPORTED;
 }