components/data_reduction_proxy/browser/data_reduction_proxy_settings.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/metrics/field_trial.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/metrics/sparse_histogram.h"
  12 #include "base/prefs/pref_member.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "base/prefs/scoped_user_pref_update.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/stringprintf.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "components/data_reduction_proxy/browser/data_reduction_proxy_auth_request_handler.h"
  20 #include "components/data_reduction_proxy/browser/data_reduction_proxy_configurator.h"
  21 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
  22 #include "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
  23 #include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
  24 #include "components/data_reduction_proxy/common/data_reduction_proxy_switches.h"
  25 #include "net/base/host_port_pair.h"
  26 #include "net/base/load_flags.h"
  27 #include "net/base/net_errors.h"
  28 #include "net/base/net_util.h"
  29 #include "net/http/http_network_session.h"
  30 #include "net/http/http_response_headers.h"
  31 #include "net/url_request/url_fetcher.h"
  32 #include "net/url_request/url_fetcher_delegate.h"
  33 #include "net/url_request/url_request_context_getter.h"
  34 #include "net/url_request/url_request_status.h"
  35 #include "url/gurl.h"
  36
  37
  38 using base::StringPrintf;
  39
  40 namespace {
  41 // Values of the UMA DataReductionProxy.NetworkChangeEvents histograms.
  42 // This enum must remain synchronized with the enum of the same
  43 // name in metrics/histograms/histograms.xml.
  44 enum DataReductionProxyNetworkChangeEvent {
  45   IP_CHANGED = 0, // The client IP address changed.
  46   DISABLED_ON_VPN = 1, // The proxy is disabled because a VPN is running.
  47   CHANGE_EVENT_COUNT = 2 // This must always be last.
  48 };
  49
  50 // Key of the UMA DataReductionProxy.StartupState histogram.
  51 const char kUMAProxyStartupStateHistogram[] =
  52     "DataReductionProxy.StartupState";
  53
  54 // Key of the UMA DataReductionProxy.ProbeURL histogram.
  55 const char kUMAProxyProbeURL[] = "DataReductionProxy.ProbeURL";
  56
  57 // Key of the UMA DataReductionProxy.ProbeURLNetError histogram.
  58 const char kUMAProxyProbeURLNetError[] = "DataReductionProxy.ProbeURLNetError";
  59
  60 // Record a network change event.
  61 void RecordNetworkChangeEvent(DataReductionProxyNetworkChangeEvent event) {
  62   UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.NetworkChangeEvents",
  63                             event,
  64                             CHANGE_EVENT_COUNT);
  65 }
  66
  67 int64 GetInt64PrefValue(const base::ListValue& list_value, size_t index) {
  68   int64 val = 0;
  69   std::string pref_value;
  70   bool rv = list_value.GetString(index, &pref_value);
  71   DCHECK(rv);
  72   if (rv) {
  73     rv = base::StringToInt64(pref_value, &val);
  74     DCHECK(rv);
  75   }
  76   return val;
  77 }
  78
  79 bool IsEnabledOnCommandLine() {
  80   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  81   return command_line.HasSwitch(
  82       data_reduction_proxy::switches::kEnableDataReductionProxy);
  83 }
  84
  85 }  // namespace
  86
  87 namespace data_reduction_proxy {
  88
  89 DataReductionProxySettings::DataReductionProxySettings(
  90     DataReductionProxyParams* params)
  91     : restricted_by_carrier_(false),
  92       enabled_by_user_(false),
  93       disabled_on_vpn_(false),
  94       unreachable_(false),
  95       prefs_(NULL),
  96       url_request_context_getter_(NULL),
  97       configurator_(NULL) {
  98   DCHECK(params);
  99   params_.reset(params);
 100 }
 101
 102 DataReductionProxySettings::~DataReductionProxySettings() {
 103   if (params_->allowed())
 104     spdy_proxy_auth_enabled_.Destroy();
 105   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 106 }
 107
 108 void DataReductionProxySettings::InitPrefMembers() {
 109   DCHECK(thread_checker_.CalledOnValidThread());
 110   spdy_proxy_auth_enabled_.Init(
 111       prefs::kDataReductionProxyEnabled,
 112       GetOriginalProfilePrefs(),
 113       base::Bind(&DataReductionProxySettings::OnProxyEnabledPrefChange,
 114                  base::Unretained(this)));
 115   data_reduction_proxy_alternative_enabled_.Init(
 116       prefs::kDataReductionProxyAltEnabled,
 117       GetOriginalProfilePrefs(),
 118       base::Bind(
 119           &DataReductionProxySettings::OnProxyAlternativeEnabledPrefChange,
 120           base::Unretained(this)));
 121 }
 122
 123 void DataReductionProxySettings::InitDataReductionProxySettings(
 124     PrefService* prefs,
 125     net::URLRequestContextGetter* url_request_context_getter) {
 126   DCHECK(thread_checker_.CalledOnValidThread());
 127   DCHECK(prefs);
 128   DCHECK(url_request_context_getter);
 129   prefs_ = prefs;
 130   url_request_context_getter_ = url_request_context_getter;
 131   InitPrefMembers();
 132   RecordDataReductionInit();
 133
 134   // Disable the proxy if it is not allowed to be used.
 135   if (!params_->allowed())
 136     return;
 137
 138   AddDefaultProxyBypassRules();
 139   net::NetworkChangeNotifier::AddIPAddressObserver(this);
 140
 141   // We set or reset the proxy pref at startup.
 142   MaybeActivateDataReductionProxy(true);
 143 }
 144
 145 void DataReductionProxySettings::InitDataReductionProxySettings(
 146     PrefService* prefs,
 147     net::URLRequestContextGetter* url_request_context_getter,
 148     DataReductionProxyConfigurator* configurator) {
 149   InitDataReductionProxySettings(prefs,
 150                                  url_request_context_getter);
 151   SetProxyConfigurator(configurator);
 152 }
 153
 154 void DataReductionProxySettings::SetDataReductionProxyStatisticsPrefs(
 155     DataReductionProxyStatisticsPrefs* statistics_prefs) {
 156   statistics_prefs_ = statistics_prefs;
 157 }
 158
 159 void DataReductionProxySettings::SetOnDataReductionEnabledCallback(
 160     const base::Callback<void(bool)>& on_data_reduction_proxy_enabled) {
 161   on_data_reduction_proxy_enabled_ = on_data_reduction_proxy_enabled;
 162   on_data_reduction_proxy_enabled_.Run(IsDataReductionProxyEnabled());
 163 }
 164
 165 void DataReductionProxySettings::SetProxyConfigurator(
 166     DataReductionProxyConfigurator* configurator) {
 167   DCHECK(configurator);
 168   configurator_ = configurator;
 169 }
 170
 171 bool DataReductionProxySettings::IsDataReductionProxyEnabled() {
 172   return spdy_proxy_auth_enabled_.GetValue() || IsEnabledOnCommandLine();
 173 }
 174
 175 bool
 176 DataReductionProxySettings::IsDataReductionProxyAlternativeEnabled() const {
 177   return data_reduction_proxy_alternative_enabled_.GetValue();
 178 }
 179
 180 bool DataReductionProxySettings::IsDataReductionProxyManaged() {
 181   return spdy_proxy_auth_enabled_.IsManaged();
 182 }
 183
 184 void DataReductionProxySettings::SetDataReductionProxyEnabled(bool enabled) {
 185   DCHECK(thread_checker_.CalledOnValidThread());
 186   // Prevent configuring the proxy when it is not allowed to be used.
 187   if (!params_->allowed())
 188     return;
 189
 190   if (spdy_proxy_auth_enabled_.GetValue() != enabled) {
 191     spdy_proxy_auth_enabled_.SetValue(enabled);
 192     OnProxyEnabledPrefChange();
 193   }
 194 }
 195
 196 void DataReductionProxySettings::SetDataReductionProxyAlternativeEnabled(
 197     bool enabled) {
 198   DCHECK(thread_checker_.CalledOnValidThread());
 199   // Prevent configuring the proxy when it is not allowed to be used.
 200   if (!params_->alternative_allowed())
 201     return;
 202   if (data_reduction_proxy_alternative_enabled_.GetValue() != enabled) {
 203     data_reduction_proxy_alternative_enabled_.SetValue(enabled);
 204     OnProxyAlternativeEnabledPrefChange();
 205   }
 206 }
 207
 208 int64 DataReductionProxySettings::GetDataReductionLastUpdateTime() {
 209   DCHECK(thread_checker_.CalledOnValidThread());
 210   DCHECK(statistics_prefs_);
 211   int64 last_update_internal =
 212       statistics_prefs_->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
 213   base::Time last_update = base::Time::FromInternalValue(last_update_internal);
 214   return static_cast<int64>(last_update.ToJsTime());
 215 }
 216
 217 DataReductionProxySettings::ContentLengthList
 218 DataReductionProxySettings::GetDailyOriginalContentLengths() {
 219   DCHECK(thread_checker_.CalledOnValidThread());
 220   return GetDailyContentLengths(prefs::kDailyHttpOriginalContentLength);
 221 }
 222
 223 void DataReductionProxySettings::SetUnreachable(bool unreachable) {
 224   unreachable_ = unreachable;
 225 }
 226
 227 bool DataReductionProxySettings::IsDataReductionProxyUnreachable() {
 228   DCHECK(thread_checker_.CalledOnValidThread());
 229   return unreachable_;
 230 }
 231
 232 DataReductionProxySettings::ContentLengthList
 233 DataReductionProxySettings::GetDailyReceivedContentLengths() {
 234   DCHECK(thread_checker_.CalledOnValidThread());
 235   return GetDailyContentLengths(prefs::kDailyHttpReceivedContentLength);
 236 }
 237
 238 void DataReductionProxySettings::OnURLFetchComplete(
 239     const net::URLFetcher* source) {
 240   DCHECK(thread_checker_.CalledOnValidThread());
 241
 242   DCHECK(source == fetcher_.get());
 243   net::URLRequestStatus status = source->GetStatus();
 244   if (status.status() == net::URLRequestStatus::FAILED) {
 245     if (status.error() == net::ERR_INTERNET_DISCONNECTED) {
 246       RecordProbeURLFetchResult(INTERNET_DISCONNECTED);
 247       return;
 248     }
 249     // TODO(bengr): Remove once we understand the reasons probes are failing.
 250     // Probe errors are either due to fetcher-level errors or modified
 251     // responses. This only tracks the former.
 252     UMA_HISTOGRAM_SPARSE_SLOWLY(
 253         kUMAProxyProbeURLNetError, std::abs(status.error()));
 254   }
 255
 256   std::string response;
 257   source->GetResponseAsString(&response);
 258
 259   if ("OK" == response.substr(0, 2)) {
 260     DVLOG(1) << "The data reduction proxy is unrestricted.";
 261
 262     if (enabled_by_user_) {
 263       if (restricted_by_carrier_) {
 264         // The user enabled the proxy, but sometime previously in the session,
 265         // the network operator had blocked the canary and restricted the user.
 266         // The current network doesn't block the canary, so don't restrict the
 267         // proxy configurations.
 268         SetProxyConfigs(true /* enabled */,
 269                         IsDataReductionProxyAlternativeEnabled(),
 270                         false /* restricted */,
 271                         false /* at_startup */);
 272         RecordProbeURLFetchResult(SUCCEEDED_PROXY_ENABLED);
 273       } else {
 274         RecordProbeURLFetchResult(SUCCEEDED_PROXY_ALREADY_ENABLED);
 275       }
 276     }
 277     restricted_by_carrier_ = false;
 278     return;
 279   }
 280   DVLOG(1) << "The data reduction proxy is restricted to the configured "
 281            << "fallback proxy.";
 282   if (enabled_by_user_) {
 283     if (!restricted_by_carrier_) {
 284       // Restrict the proxy.
 285       SetProxyConfigs(true /* enabled */,
 286                       IsDataReductionProxyAlternativeEnabled(),
 287                       true /* restricted */,
 288                       false /* at_startup */);
 289       RecordProbeURLFetchResult(FAILED_PROXY_DISABLED);
 290     } else {
 291       RecordProbeURLFetchResult(FAILED_PROXY_ALREADY_DISABLED);
 292     }
 293   }
 294   restricted_by_carrier_ = true;
 295 }
 296
 297 PrefService* DataReductionProxySettings::GetOriginalProfilePrefs() {
 298   DCHECK(thread_checker_.CalledOnValidThread());
 299   return prefs_;
 300 }
 301
 302 void DataReductionProxySettings::AddDefaultProxyBypassRules() {
 303   // localhost
 304   DCHECK(configurator_);
 305   configurator_->AddHostPatternToBypass("<local>");
 306   // RFC1918 private addresses.
 307   configurator_->AddHostPatternToBypass("10.0.0.0/8");
 308   configurator_->AddHostPatternToBypass("172.16.0.0/12");
 309   configurator_->AddHostPatternToBypass("192.168.0.0/16");
 310   // RFC4193 private addresses.
 311   configurator_->AddHostPatternToBypass("fc00::/7");
 312   // IPV6 probe addresses.
 313   configurator_->AddHostPatternToBypass("*-ds.metric.gstatic.com");
 314   configurator_->AddHostPatternToBypass("*-v4.metric.gstatic.com");
 315 }
 316
 317 void DataReductionProxySettings::LogProxyState(
 318     bool enabled, bool restricted, bool at_startup) {
 319   // This must stay a LOG(WARNING); the output is used in processing customer
 320   // feedback.
 321   const char kAtStartup[] = "at startup";
 322   const char kByUser[] = "by user action";
 323   const char kOn[] = "ON";
 324   const char kOff[] = "OFF";
 325   const char kRestricted[] = "(Restricted)";
 326   const char kUnrestricted[] = "(Unrestricted)";
 327
 328   std::string annotated_on =
 329       kOn + std::string(" ") + (restricted ? kRestricted : kUnrestricted);
 330
 331   LOG(WARNING) << "SPDY proxy " << (enabled ? annotated_on : kOff)
 332                << " " << (at_startup ? kAtStartup : kByUser);
 333 }
 334
 335 void DataReductionProxySettings::OnIPAddressChanged() {
 336   DCHECK(thread_checker_.CalledOnValidThread());
 337   if (enabled_by_user_) {
 338     DCHECK(params_->allowed());
 339     RecordNetworkChangeEvent(IP_CHANGED);
 340     if (DisableIfVPN())
 341       return;
 342     if (IsDataReductionProxyAlternativeEnabled() &&
 343         !params_->alternative_fallback_allowed()) {
 344       return;
 345     }
 346     ProbeWhetherDataReductionProxyIsAvailable();
 347   }
 348 }
 349
 350 void DataReductionProxySettings::OnProxyEnabledPrefChange() {
 351   DCHECK(thread_checker_.CalledOnValidThread());
 352   if (!on_data_reduction_proxy_enabled_.is_null())
 353     on_data_reduction_proxy_enabled_.Run(IsDataReductionProxyEnabled());
 354   if (!params_->allowed())
 355     return;
 356   MaybeActivateDataReductionProxy(false);
 357 }
 358
 359 void DataReductionProxySettings::OnProxyAlternativeEnabledPrefChange() {
 360   DCHECK(thread_checker_.CalledOnValidThread());
 361   if (!params_->alternative_allowed())
 362     return;
 363   MaybeActivateDataReductionProxy(false);
 364 }
 365
 366 void DataReductionProxySettings::ResetDataReductionStatistics() {
 367   DCHECK(thread_checker_.CalledOnValidThread());
 368   DCHECK(statistics_prefs_);
 369   base::ListValue* original_update =
 370       statistics_prefs_->GetList(prefs::kDailyHttpOriginalContentLength);
 371   base::ListValue* received_update =
 372       statistics_prefs_->GetList(prefs::kDailyHttpReceivedContentLength);
 373   original_update->Clear();
 374   received_update->Clear();
 375   for (size_t i = 0; i < kNumDaysInHistory; ++i) {
 376     original_update->AppendString(base::Int64ToString(0));
 377     received_update->AppendString(base::Int64ToString(0));
 378   }
 379 }
 380
 381 void DataReductionProxySettings::MaybeActivateDataReductionProxy(
 382     bool at_startup) {
 383   DCHECK(thread_checker_.CalledOnValidThread());
 384   PrefService* prefs = GetOriginalProfilePrefs();
 385   // TODO(marq): Consider moving this so stats are wiped the first time the
 386   // proxy settings are actually (not maybe) turned on.
 387   if (spdy_proxy_auth_enabled_.GetValue() &&
 388       !prefs->GetBoolean(prefs::kDataReductionProxyWasEnabledBefore)) {
 389     prefs->SetBoolean(prefs::kDataReductionProxyWasEnabledBefore, true);
 390     ResetDataReductionStatistics();
 391   }
 392   // Configure use of the data reduction proxy if it is enabled.
 393   enabled_by_user_= IsDataReductionProxyEnabled();
 394   SetProxyConfigs(enabled_by_user_ && !disabled_on_vpn_,
 395                   IsDataReductionProxyAlternativeEnabled(),
 396                   restricted_by_carrier_,
 397                   at_startup);
 398
 399   // Check if the proxy has been restricted explicitly by the carrier.
 400   if (enabled_by_user_ && !disabled_on_vpn_ &&
 401       !(IsDataReductionProxyAlternativeEnabled() &&
 402         !params_->alternative_fallback_allowed())) {
 403     ProbeWhetherDataReductionProxyIsAvailable();
 404   }
 405 }
 406
 407 void DataReductionProxySettings::SetProxyConfigs(bool enabled,
 408                                                  bool alternative_enabled,
 409                                                  bool restricted,
 410                                                  bool at_startup) {
 411   DCHECK(thread_checker_.CalledOnValidThread());
 412   DCHECK(configurator_);
 413
 414   LogProxyState(enabled, restricted, at_startup);
 415   // The alternative is only configured if the standard configuration is
 416   // is enabled.
 417   if (enabled & !params_->holdback()) {
 418     if (alternative_enabled) {
 419       configurator_->Enable(restricted,
 420                             !params_->alternative_fallback_allowed(),
 421                             params_->alt_origin().spec(),
 422                             std::string(),
 423                             params_->ssl_origin().spec());
 424     } else {
 425       configurator_->Enable(restricted,
 426                             !params_->fallback_allowed(),
 427                             params_->origin().spec(),
 428                             params_->fallback_origin().spec(),
 429                             std::string());
 430     }
 431   } else {
 432     configurator_->Disable();
 433   }
 434 }
 435
 436 // Metrics methods
 437 void DataReductionProxySettings::RecordDataReductionInit() {
 438   DCHECK(thread_checker_.CalledOnValidThread());
 439   ProxyStartupState state = PROXY_NOT_AVAILABLE;
 440   if (params_->allowed()) {
 441     if (IsDataReductionProxyEnabled())
 442       state = PROXY_ENABLED;
 443     else
 444       state = PROXY_DISABLED;
 445   }
 446
 447   RecordStartupState(state);
 448 }
 449
 450 void DataReductionProxySettings::RecordProbeURLFetchResult(
 451     ProbeURLFetchResult result) {
 452   UMA_HISTOGRAM_ENUMERATION(kUMAProxyProbeURL,
 453                             result,
 454                             PROBE_URL_FETCH_RESULT_COUNT);
 455 }
 456
 457 void DataReductionProxySettings::RecordStartupState(ProxyStartupState state) {
 458   UMA_HISTOGRAM_ENUMERATION(kUMAProxyStartupStateHistogram,
 459                             state,
 460                             PROXY_STARTUP_STATE_COUNT);
 461 }
 462
 463 void DataReductionProxySettings::GetNetworkList(
 464     net::NetworkInterfaceList* interfaces,
 465     int policy) {
 466   net::GetNetworkList(interfaces, policy);
 467 }
 468
 469 void DataReductionProxySettings::ResetParamsForTest(
 470     DataReductionProxyParams* params) {
 471   params_.reset(params);
 472 }
 473
 474 DataReductionProxySettings::ContentLengthList
 475 DataReductionProxySettings::GetDailyContentLengths(const char* pref_name) {
 476   DCHECK(thread_checker_.CalledOnValidThread());
 477   DataReductionProxySettings::ContentLengthList content_lengths;
 478   DCHECK(statistics_prefs_);
 479   const base::ListValue* list_value = statistics_prefs_->GetList(pref_name);
 480   if (list_value->GetSize() == kNumDaysInHistory) {
 481     for (size_t i = 0; i < kNumDaysInHistory; ++i) {
 482       content_lengths.push_back(GetInt64PrefValue(*list_value, i));
 483     }
 484   }
 485   return content_lengths;
 486 }
 487
 488 void DataReductionProxySettings::GetContentLengths(
 489     unsigned int days,
 490     int64* original_content_length,
 491     int64* received_content_length,
 492     int64* last_update_time) {
 493   DCHECK(thread_checker_.CalledOnValidThread());
 494   DCHECK_LE(days, kNumDaysInHistory);
 495   DCHECK(statistics_prefs_);
 496
 497   const base::ListValue* original_list =
 498       statistics_prefs_->GetList(prefs::kDailyHttpOriginalContentLength);
 499   const base::ListValue* received_list =
 500       statistics_prefs_->GetList(prefs::kDailyHttpReceivedContentLength);
 501
 502   if (original_list->GetSize() != kNumDaysInHistory ||
 503       received_list->GetSize() != kNumDaysInHistory) {
 504     *original_content_length = 0L;
 505     *received_content_length = 0L;
 506     *last_update_time = 0L;
 507     return;
 508   }
 509
 510   int64 orig = 0L;
 511   int64 recv = 0L;
 512   // Include days from the end of the list going backwards.
 513   for (size_t i = kNumDaysInHistory - days;
 514        i < kNumDaysInHistory; ++i) {
 515     orig += GetInt64PrefValue(*original_list, i);
 516     recv += GetInt64PrefValue(*received_list, i);
 517   }
 518   *original_content_length = orig;
 519   *received_content_length = recv;
 520   *last_update_time =
 521       statistics_prefs_->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
 522 }
 523
 524 net::URLFetcher* DataReductionProxySettings::GetBaseURLFetcher(
 525     const GURL& gurl,
 526     int load_flags) {
 527
 528   net::URLFetcher* fetcher = net::URLFetcher::Create(gurl,
 529                                                      net::URLFetcher::GET,
 530                                                      this);
 531   fetcher->SetLoadFlags(load_flags);
 532   DCHECK(url_request_context_getter_);
 533   fetcher->SetRequestContext(url_request_context_getter_);
 534   // Configure max retries to be at most kMaxRetries times for 5xx errors.
 535   static const int kMaxRetries = 5;
 536   fetcher->SetMaxRetriesOn5xx(kMaxRetries);
 537   fetcher->SetAutomaticallyRetryOnNetworkChanges(kMaxRetries);
 538   return fetcher;
 539 }
 540
 541
 542 net::URLFetcher*
 543 DataReductionProxySettings::GetURLFetcherForAvailabilityCheck() {
 544   return GetBaseURLFetcher(params_->probe_url(),
 545                            net::LOAD_DISABLE_CACHE | net::LOAD_BYPASS_PROXY);
 546 }
 547
 548
 549 void DataReductionProxySettings::ProbeWhetherDataReductionProxyIsAvailable() {
 550   net::URLFetcher* fetcher = GetURLFetcherForAvailabilityCheck();
 551   if (!fetcher)
 552     return;
 553   fetcher_.reset(fetcher);
 554   fetcher_->Start();
 555 }
 556
 557 bool DataReductionProxySettings::DisableIfVPN() {
 558   net::NetworkInterfaceList network_interfaces;
 559   GetNetworkList(&network_interfaces, 0);
 560   // VPNs use a "tun" interface, so the presence of a "tun" interface indicates
 561   // a VPN is in use.
 562   // TODO(kundaji): Verify this works on Windows.
 563   const std::string vpn_interface_name_prefix = "tun";
 564   for (size_t i = 0; i < network_interfaces.size(); ++i) {
 565     std::string interface_name = network_interfaces[i].name;
 566     if (LowerCaseEqualsASCII(
 567         interface_name.begin(),
 568         interface_name.begin() + vpn_interface_name_prefix.size(),
 569         vpn_interface_name_prefix.c_str())) {
 570       SetProxyConfigs(false,
 571                       IsDataReductionProxyAlternativeEnabled(),
 572                       false,
 573                       false);
 574       disabled_on_vpn_ = true;
 575       RecordNetworkChangeEvent(DISABLED_ON_VPN);
 576       return true;
 577     }
 578   }
 579   if (disabled_on_vpn_) {
 580     SetProxyConfigs(enabled_by_user_,
 581                     IsDataReductionProxyAlternativeEnabled(),
 582                     restricted_by_carrier_,
 583                     false);
 584   }
 585   disabled_on_vpn_ = false;
 586   return false;
 587 }
 588
 589 }  // namespace data_reduction_proxy