Bypass data reduction proxy when using VPN

components/data_reduction_proxy/browser/data_reduction_proxy_settings.cc

 // Copyright 2014 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 "components/data_reduction_proxy/browser/data_reduction_proxy_settings.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_auth_request_handler.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_configurator.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_params.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_usage_stats.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_pref_names.h"
 #include "components/data_reduction_proxy/common/data_reduction_proxy_switches.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 
 using base::StringPrintf;
 
 namespace {
+// Values of the UMA DataReductionProxy.NetworkChangeEvents histograms.
+// This enum must remain synchronized with the enum of the same
+// name in metrics/histograms/histograms.xml.
+enum DataReductionProxyNetworkChangeEvents {
+  // The client IP address changed.

[marq (ping after 24h), 2014/07/11 16:31:56]

Use a more vertically-compact formatting:

  
  IP_CHANGED = 0,  // The client IP address changed.
  DISABLED_ON_VPN = 1,   // The proxy is disabled because a VPN is running.
  CHANGE_EVENT_TYPE_MAX = 2  // This must always be last.

Also, the prevailing style in Chrome seems to be to name the last UMA enum value
<something>_COUNT, so CHANGE_EVENT_TYPE_COUNT here (or maybe
NETWORK_CHANGE_EVENT_COUNT, to match the UMA name).

[bengr, 2014/07/11 22:49:15]

Done.

+  IP_CHANGED = 0,
+
+  // The proxy is disabled because a VPN is running.
+  DISABLED_ON_VPN = 1,
+
+  // This must always be last.
+  CHANGE_EVENT_TYPE_MAX =2

[Ilya Sherman, 2014/07/11 03:45:52]

nit: Please add a space after the '=' sign.

[bengr, 2014/07/11 22:49:15]

Done.

+};
 
 // Key of the UMA DataReductionProxy.StartupState histogram.
 const char kUMAProxyStartupStateHistogram[] =
     "DataReductionProxy.StartupState";
 
 // Key of the UMA DataReductionProxy.ProbeURL histogram.
 const char kUMAProxyProbeURL[] = "DataReductionProxy.ProbeURL";
 
 int64 GetInt64PrefValue(const base::ListValue& list_value, size_t index) {
   int64 val = 0;
@@ skipping 14 matching lines @@
 }
 
 }  // namespace
 
 namespace data_reduction_proxy {
 
 DataReductionProxySettings::DataReductionProxySettings(
     DataReductionProxyParams* params)
     : restricted_by_carrier_(false),
       enabled_by_user_(false),
+      disabled_on_vpn_(false),
       prefs_(NULL),
       local_state_prefs_(NULL),
-      url_request_context_getter_(NULL) {
+      url_request_context_getter_(NULL),
+      usage_stats_(NULL) {
   DCHECK(params);
   params_.reset(params);
 }
 
 DataReductionProxySettings::~DataReductionProxySettings() {
   if (params_->allowed())
     spdy_proxy_auth_enabled_.Destroy();
 }
 
 void DataReductionProxySettings::InitPrefMembers() {
@@ skipping 218 matching lines @@
       kOn + std::string(" ") + (restricted ? kRestricted : kUnrestricted);
 
   LOG(WARNING) << "SPDY proxy " << (enabled ? annotated_on : kOff)
                << " " << (at_startup ? kAtStartup : kByUser);
 }
 
 void DataReductionProxySettings::OnIPAddressChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (enabled_by_user_) {
     DCHECK(params_->allowed());
+    UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.NetworkChangeEvents",
+                              IP_CHANGED,
+                              CHANGE_EVENT_TYPE_MAX);
+    if (DisableIfVPN())
+      return;
     ProbeWhetherDataReductionProxyIsAvailable();
     WarmProxyConnection();
   }
 }
 
 void DataReductionProxySettings::OnProxyEnabledPrefChange() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!params_->allowed())
     return;
   MaybeActivateDataReductionProxy(false);
@@ skipping 28 matching lines @@
   // TODO(marq): Consider moving this so stats are wiped the first time the
   // proxy settings are actually (not maybe) turned on.
   if (spdy_proxy_auth_enabled_.GetValue() &&
       !prefs->GetBoolean(prefs::kDataReductionProxyWasEnabledBefore)) {
     prefs->SetBoolean(prefs::kDataReductionProxyWasEnabledBefore, true);
     ResetDataReductionStatistics();
   }
 
   // Configure use of the data reduction proxy if it is enabled.
   enabled_by_user_= IsDataReductionProxyEnabled();
-  SetProxyConfigs(enabled_by_user_,
+  SetProxyConfigs(enabled_by_user_ && !disabled_on_vpn_,
                   IsDataReductionProxyAlternativeEnabled(),
                   restricted_by_carrier_,
                   at_startup);
 
   // Check if the proxy has been restricted explicitly by the carrier.
-  if (enabled_by_user_) {
+  if (enabled_by_user_ && !disabled_on_vpn_) {
     ProbeWhetherDataReductionProxyIsAvailable();
     WarmProxyConnection();
   }
 }
 
 void DataReductionProxySettings::SetProxyConfigs(bool enabled,
                                                  bool alternative_enabled,
                                                  bool restricted,
                                                  bool at_startup) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 39 matching lines @@
                             result,
                             PROBE_URL_FETCH_RESULT_COUNT);
 }
 
 void DataReductionProxySettings::RecordStartupState(ProxyStartupState state) {
   UMA_HISTOGRAM_ENUMERATION(kUMAProxyStartupStateHistogram,
                             state,
                             PROXY_STARTUP_STATE_COUNT);
 }
 
+void DataReductionProxySettings::GetNetworkList(
+    net::NetworkInterfaceList* interfaces,
+    int policy) {
+  net::GetNetworkList(interfaces, policy);
+

[marq (ping after 24h), 2014/07/11 16:31:56]

Extra line.

[bengr, 2014/07/11 22:49:16]

Done.

+}
+
 void DataReductionProxySettings::ResetParamsForTest(
     DataReductionProxyParams* params) {
   params_.reset(params);
 }
 
 DataReductionProxySettings::ContentLengthList
 DataReductionProxySettings::GetDailyContentLengths(const char* pref_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DataReductionProxySettings::ContentLengthList content_lengths;
   const base::ListValue* list_value = GetLocalStatePrefs()->GetList(pref_name);
@@ skipping 40 matching lines @@
        i < kNumDaysInHistory; ++i) {
     orig += GetInt64PrefValue(*original_list, i);
     recv += GetInt64PrefValue(*received_list, i);
   }
   *original_content_length = orig;
   *received_content_length = recv;
   *last_update_time =
       local_state->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
 }
 
-// static
-base::string16 DataReductionProxySettings::AuthHashForSalt(
-    int64 salt,
-    const std::string& key) {
-  std::string salted_key =
-      base::StringPrintf("%lld%s%lld",
-                         static_cast<long long>(salt),
-                         key.c_str(),
-                         static_cast<long long>(salt));
-  return base::UTF8ToUTF16(base::MD5String(salted_key));
-}
-
 net::URLFetcher* DataReductionProxySettings::GetBaseURLFetcher(
     const GURL& gurl,
     int load_flags) {
 
   net::URLFetcher* fetcher = net::URLFetcher::Create(gurl,
                                                      net::URLFetcher::GET,
                                                      this);
   fetcher->SetLoadFlags(load_flags);
   DCHECK(url_request_context_getter_);
   fetcher->SetRequestContext(url_request_context_getter_);
@@ skipping 25 matching lines @@
 }
 
 void DataReductionProxySettings::WarmProxyConnection() {
   net::URLFetcher* fetcher = GetURLFetcherForWarmup();
   if (!fetcher)
     return;
   warmup_fetcher_.reset(fetcher);
   warmup_fetcher_->Start();
 }
 
+bool DataReductionProxySettings::DisableIfVPN() {
+  net::NetworkInterfaceList network_interfaces;
+  GetNetworkList(&network_interfaces, 0);
+  const std::string vpn_interface_name_prefix = "tun";

[marq (ping after 24h), 2014/07/11 16:31:56]

Please add some comments explaining how this logic determines if the device is
on a VPN. What's the significance of "tun"?

Also, on what platforms is "tun" the interface prefix for the VPN?  If this
logic isn't supported on all platforms, appropriate comments should be made in
the header file.

[bengr, 2014/07/11 22:49:15]

I added a comment. This will work on all Unix-derived platforms. (We'll need to
verify on iOS.) When we port the proxy to Windows, we might need special logic.
I added a TODO.

+  for (size_t i = 0; i < network_interfaces.size(); ++i) {
+    std::string interface_name = network_interfaces[i].name;
+    if (LowerCaseEqualsASCII(
+        interface_name.begin(),
+        interface_name.begin() + vpn_interface_name_prefix.size(),
+        vpn_interface_name_prefix.c_str())) {
+      SetProxyConfigs(false,
+                      IsDataReductionProxyAlternativeEnabled(),
+                      false,
+                      false);
+      disabled_on_vpn_ = true;
+      UMA_HISTOGRAM_ENUMERATION("DataReductionProxy.NetworkChangeEvents",
+                                DISABLED_ON_VPN,
+                                CHANGE_EVENT_TYPE_MAX);

[Ilya Sherman, 2014/07/11 03:45:53]

nit: Please factor out a method for emitting to this histogram, so that there's
less chance that one of the codepaths will have a typo in it.

[marq (ping after 24h), 2014/07/11 16:31:56]

Or at least factor the UMA name into a constant.

[bengr, 2014/07/11 22:49:15]

Done.

[bengr, 2014/07/11 22:49:15]

Done.

+      return true;
+    }
+  }
+  disabled_on_vpn_ = false;
+  return false;
+}
+
 }  // namespace data_reduction_proxy