#include "chrome/common/chrome_switches.h"
#include "chrome/common/chrome_version_info.h"
#include "chrome/common/pref_names.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_auth_request_handler.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_delegate.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_prefs.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_protocol.h"
-#include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_auth_request_handler.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_delegate.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_prefs.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_protocol.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
+#include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
#include "components/policy/core/common/policy_service.h"
#include "components/variations/variations_associated_data.h"
#include "content/public/browser/browser_thread.h"
const char kQuicFieldTrialHttpsEnabledGroupName[] = "HttpsEnabled";
const char kQuicFieldTrialPacketLengthSuffix[] = "BytePackets";
const char kQuicFieldTrialPacingSuffix[] = "WithPacing";
-const char kQuicFieldTrialTimeBasedLossDetectionSuffix[] =
- "WithTimeBasedLossDetection";
// The SPDY trial composes two different trial plus control groups:
// * A "holdback" group with SPDY disabled, and corresponding control
const char kSpdyFieldTrialSpdy4GroupNamePrefix[] = "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));
}
private:
- virtual ~SystemURLRequestContext() {
+ ~SystemURLRequestContext() override {
AssertNoURLRequests();
#if defined(USE_NSS) || defined(OS_IOS)
net::SetURLRequestContextForNSSHttpIO(NULL);
// rules on top of the real host resolver. This allows forwarding all requests
// through a designated test server.
if (!command_line.HasSwitch(switches::kHostResolverRules))
- return global_host_resolver.PassAs<net::HostResolver>();
+ return global_host_resolver.Pass();
scoped_ptr<net::MappedHostResolver> remapped_resolver(
new net::MappedHostResolver(global_host_resolver.Pass()));
remapped_resolver->SetRulesFromString(
command_line.GetSwitchValueASCII(switches::kHostResolverRules));
- return remapped_resolver.PassAs<net::HostResolver>();
+ return remapped_resolver.Pass();
}
// TODO(willchan): Remove proxy script fetcher context since it's not necessary
return it->second;
}
+// Return true if stale-while-revalidate support should be enabled.
+bool IsStaleWhileRevalidateEnabled(const base::CommandLine& command_line) {
+ if (command_line.HasSwitch(switches::kEnableStaleWhileRevalidate))
+ return true;
+ const std::string group_name =
+ base::FieldTrialList::FindFullName(kStaleWhileRevalidateFieldTrialName);
+ return group_name == "Enabled";
+}
+
} // namespace
class IOThread::LoggingNetworkChangeObserver
net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
}
- virtual ~LoggingNetworkChangeObserver() {
+ ~LoggingNetworkChangeObserver() override {
net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
}
// NetworkChangeNotifier::IPAddressObserver implementation.
- virtual void OnIPAddressChanged() OVERRIDE {
+ void OnIPAddressChanged() override {
VLOG(1) << "Observed a change to the network IP addresses";
net_log_->AddGlobalEntry(net::NetLog::TYPE_NETWORK_IP_ADDRESSES_CHANGED);
}
// NetworkChangeNotifier::ConnectionTypeObserver implementation.
- virtual void OnConnectionTypeChanged(
- net::NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+ void OnConnectionTypeChanged(
+ net::NetworkChangeNotifier::ConnectionType type) override {
std::string type_as_string =
net::NetworkChangeNotifier::ConnectionTypeToString(type);
}
// NetworkChangeNotifier::NetworkChangeObserver implementation.
- virtual void OnNetworkChanged(
- net::NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+ void OnNetworkChanged(
+ net::NetworkChangeNotifier::ConnectionType type) override {
std::string type_as_string =
net::NetworkChangeNotifier::ConnectionTypeToString(type);
explicit SystemURLRequestContextGetter(IOThread* io_thread);
// Implementation for net::UrlRequestContextGetter.
- virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
- virtual scoped_refptr<base::SingleThreadTaskRunner>
- GetNetworkTaskRunner() const OVERRIDE;
+ net::URLRequestContext* GetURLRequestContext() override;
+ scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
+ const override;
protected:
- virtual ~SystemURLRequestContextGetter();
+ ~SystemURLRequestContextGetter() override;
private:
IOThread* const io_thread_; // Weak pointer, owned by BrowserProcess.
: 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) {
globals_->enable_ssl_connect_job_waiting = true;
if (command_line.HasSwitch(switches::kIgnoreCertificateErrors))
globals_->ignore_certificate_errors = true;
+ globals_->use_stale_while_revalidate =
+ IsStaleWhileRevalidateEnabled(command_line);
if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
globals_->testing_fixed_http_port =
GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpPort);
new net::FtpProtocolHandler(
globals_->proxy_script_fetcher_ftp_transaction_factory.get()));
#endif
- globals_->proxy_script_fetcher_url_request_job_factory =
- job_factory.PassAs<net::URLRequestJobFactory>();
+ globals_->proxy_script_fetcher_url_request_job_factory = job_factory.Pass();
globals_->throttler_manager.reset(new net::URLRequestThrottlerManager());
globals_->throttler_manager->set_net_log(net_log_);
} else if (command_line.HasSwitch(switches::kEnableSpdy4)) {
globals_->next_protos = net::NextProtosSpdy4Http2();
globals_->use_alternate_protocols.set(true);
- } else if (command_line.HasSwitch(switches::kDisableSpdy31)) {
- globals_->next_protos = net::NextProtosSpdy3();
- globals_->use_alternate_protocols.set(true);
} else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
globals_->next_protos = net::NextProtosHttpOnly();
globals_->use_alternate_protocols.set(false);
globals->use_alternate_protocols.set(true);
} else if (spdy_trial_group.starts_with(
kSpdyFieldTrialSpdy31GroupNamePrefix)) {
- globals->next_protos = net::NextProtosSpdy4Http2();
+ globals->next_protos = net::NextProtosSpdy31();
globals->use_alternate_protocols.set(true);
} else if (spdy_trial_group.starts_with(
kSpdyFieldTrialSpdy4GroupNamePrefix)) {
if (option == kOff) {
net::HttpStreamFactory::set_spdy_enabled(false);
} else if (option == kDisableSSL) {
- globals_->spdy_default_protocol.set(net::kProtoSPDY3);
+ globals_->spdy_default_protocol.set(net::kProtoSPDY31);
globals_->force_spdy_over_ssl.set(false);
globals_->force_spdy_always.set(true);
} else if (option == kSSL) {
- globals_->spdy_default_protocol.set(net::kProtoSPDY3);
+ globals_->spdy_default_protocol.set(net::kProtoSPDY31);
globals_->force_spdy_over_ssl.set(true);
globals_->force_spdy_always.set(true);
} else if (option == kDisablePing) {
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.enable_tcp_fast_open_for_ssl.CopyToIfSet(
¶ms->enable_websocket_over_spdy);
globals.enable_quic.CopyToIfSet(¶ms->enable_quic);
- globals.enable_quic_time_based_loss_detection.CopyToIfSet(
- ¶ms->enable_quic_time_based_loss_detection);
globals.quic_always_require_handshake_confirmation.CopyToIfSet(
¶ms->quic_always_require_handshake_confirmation);
globals.quic_disable_connection_pooling.CopyToIfSet(
¶ms->quic_disable_connection_pooling);
+ globals.quic_load_server_info_timeout_ms.CopyToIfSet(
+ ¶ms->quic_load_server_info_timeout_ms);
globals.enable_quic_port_selection.CopyToIfSet(
¶ms->enable_quic_port_selection);
globals.quic_max_packet_length.CopyToIfSet(¶ms->quic_max_packet_length);
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
globals_->data_reduction_proxy_delegate.reset(
new data_reduction_proxy::DataReductionProxyDelegate(
- globals_->data_reduction_proxy_auth_request_handler.get()));
+ globals_->data_reduction_proxy_auth_request_handler.get(),
+ globals_->data_reduction_proxy_params.get()));
// This is the same as in ProfileImplIOData except that we do not collect
// usage stats.
network_delegate->set_data_reduction_proxy_params(
bool enable_quic = ShouldEnableQuic(command_line, quic_trial_group);
globals->enable_quic.set(enable_quic);
if (enable_quic) {
- globals->enable_quic_time_based_loss_detection.set(
- ShouldEnableQuicTimeBasedLossDetection(command_line, quic_trial_group,
- quic_trial_params));
globals->quic_always_require_handshake_confirmation.set(
ShouldQuicAlwaysRequireHandshakeConfirmation(quic_trial_params));
globals->quic_disable_connection_pooling.set(
ShouldQuicDisableConnectionPooling(quic_trial_params));
+ int load_server_info_timeout_ms =
+ GetQuicLoadServerInfoTimeout(quic_trial_params);
+ if (load_server_info_timeout_ms != 0) {
+ globals->quic_load_server_info_timeout_ms.set(
+ load_server_info_timeout_ms);
+ }
globals->enable_quic_port_selection.set(
ShouldEnableQuicPortSelection(command_line));
globals->quic_connection_options =
}
// static
-bool IOThread::ShouldEnableQuicTimeBasedLossDetection(
- const CommandLine& command_line,
- base::StringPiece quic_trial_group,
- const VariationParameters& quic_trial_params) {
- if (command_line.HasSwitch(switches::kEnableQuicTimeBasedLossDetection))
- return true;
-
- if (command_line.HasSwitch(switches::kDisableQuicTimeBasedLossDetection))
- return false;
-
- if (LowerCaseEqualsASCII(
- GetVariationParam(quic_trial_params, "enable_time_based_loss_detection"),
- "true"))
- return true;
-
- return quic_trial_group.ends_with(
- kQuicFieldTrialTimeBasedLossDetectionSuffix);
-}
-
-// static
bool IOThread::ShouldQuicAlwaysRequireHandshakeConfirmation(
const VariationParameters& quic_trial_params) {
return LowerCaseEqualsASCII(
}
// static
+int IOThread::GetQuicLoadServerInfoTimeout(
+ const VariationParameters& quic_trial_params) {
+ int value;
+ if (base::StringToInt(GetVariationParam(quic_trial_params,
+ "load_server_info_timeout"),
+ &value)) {
+ return value;
+ }
+ return 0;
+}
+
+// static
size_t IOThread::GetQuicMaxPacketLength(
const CommandLine& command_line,
base::StringPiece quic_trial_group,
projects / platform / framework / web / crosswalk.git / blobdiff