Added probe to determine if data reduction proxy can be used

chrome/browser/net/spdyproxy/data_reduction_proxy_settings_android.cc

+// Copyright 2013 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/net/spdyproxy/data_reduction_proxy_settings_android.h"
+
+#include "base/android/build_info.h"
+#include "base/android/jni_android.h"
+#include "base/android/jni_string.h"
+#include "base/base64.h"
+#include "base/command_line.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
+#include "base/prefs/pref_service.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 "chrome/browser/browser_process.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
+#include "jni/DataReductionProxySettingsAndroid_jni.h"
+#include "net/base/load_flags.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_status.h"
+#include "url/gurl.h"
+
+using base::android::CheckException;
+using base::android::ConvertJavaStringToUTF8;
+using base::android::ConvertUTF8ToJavaString;
+using base::android::ScopedJavaLocalRef;
+using base::StringPrintf;
+
+
+namespace {
+
+// The c++ definition of enum SpdyProxyAuthState defined in
+// tools/histograms/histograms.xml.
+enum {
+  CHROME_STARTUP,
+  SPDY_PROXY_AUTH_ON_AT_STARTUP,
+  SPDY_PROXY_AUTH_ON_BY_USER,
+  SPDY_PROXY_AUTH_OFF_BY_USER,
+  // Used by UMA histograms and should always be the last value.
+  NUM_SPDY_PROXY_AUTH_STATE
+};
+
+// SpdyProxyValue switch.
+const char kSpdyProxyValueSwitch[] = "spdy-proxy-auth-value";
+
+const unsigned int kNumDaysInHistory = 60;
+const unsigned int kNumDaysInHistorySummary = 30;
+
+}  // namespace
+
+DataReductionProxySettingsAndroid::DataReductionProxySettingsAndroid(
+    JNIEnv* env, jobject obj) :
+    has_turned_on_(false),
+    has_turned_off_(false),
+    disabled_by_carrier_(false),
+    enabled_by_user_(false) {
+  AddDefaultProxyBypassRules();
+  net::NetworkChangeNotifier::AddIPAddressObserver(this);
+}
+
+DataReductionProxySettingsAndroid::~DataReductionProxySettingsAndroid() {
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyAvailable(
+    JNIEnv* env, jobject obj) {
+  return IsDataReductionProxyAvailable();
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyPromoAvailable(
+    JNIEnv* env, jobject obj) {
+  return IsDataReductionProxyPromoAvailable();
+}
+
+ScopedJavaLocalRef<jstring>
+DataReductionProxySettingsAndroid::GetDataReductionProxyOrigin(
+    JNIEnv* env, jobject obj) {
+  if (!IsDataReductionProxyAvailable())
+    ConvertUTF8ToJavaString(env, std::string());
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kSpdyProxyAuthOrigin)) {
+    return ConvertUTF8ToJavaString(env, command_line.GetSwitchValueASCII(
+            switches::kSpdyProxyAuthOrigin));
+  }
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+  return ConvertUTF8ToJavaString(env, SPDY_PROXY_AUTH_ORIGIN);
+#endif
+  return ConvertUTF8ToJavaString(env, std::string());
+}
+
+ScopedJavaLocalRef<jstring>
+DataReductionProxySettingsAndroid::GetDataReductionProxyValue(
+    JNIEnv* env, jobject obj) {
+  if (!IsDataReductionProxyAvailable())
+    return ConvertUTF8ToJavaString(env, std::string());
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kSpdyProxyAuthOrigin)) {
+    // If an origin is provided via a switch, then only consider the value
+    // that is provided by a switch. Do not use the preprocessor constant.
+    if (command_line.HasSwitch(kSpdyProxyValueSwitch)) {
+      return ConvertUTF8ToJavaString(env,
+          command_line.GetSwitchValueASCII(kSpdyProxyValueSwitch));
+    }
+  }
+#if defined(SPDY_PROXY_AUTH_VALUE)
+  return ConvertUTF8ToJavaString(env, SPDY_PROXY_AUTH_VALUE);
+#endif
+  return ConvertUTF8ToJavaString(env, std::string());
+}
+
+jlong DataReductionProxySettingsAndroid::GetDataReductionLastUpdateTime(
+    JNIEnv* env, jobject obj) {
+  PrefService* local_state = g_browser_process->local_state();
+  int64 last_update_internal =
+      local_state->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
+  base::Time last_update = base::Time::FromInternalValue(last_update_internal);
+  return static_cast<int64>(last_update.ToJsTime());
+}
+
+base::android::ScopedJavaLocalRef<jobject>
+DataReductionProxySettingsAndroid::GetContentLengths(JNIEnv* env,
+                                                 jobject obj) {
+  int64 original_content_length;
+  int64 received_content_length;
+  int64 last_update_internal;
+  GetContentLengths(kNumDaysInHistorySummary, &original_content_length,
+                    &received_content_length, &last_update_internal);
+
+  return Java_ContentLengths_create(env,
+                                    original_content_length,
+                                    received_content_length);
+}
+
+void DataReductionProxySettingsAndroid::AddDefaultProxyBypassRules() {
+  // localhost
+  AddHostToBypass("localhost");
+  AddHostPatternToBypass("localhost.*");
+  AddHostToBypass("127.0.0.1");
+
+  // BUG(169959): For some reason DataReductionProxy is breaking the omnibox

[nyquist, 2013/09/04 02:20:15]

TODO(bengr): ...blah... See: http://crbug.com/169959

[bengr, 2013/09/05 02:03:49]

Done.

+  // SearchProvider.  Remove this rule when this is fixed.
+  AddURLSubstringToBypass(
+                          "http://www.google.com/complete/search", 0, 37);
+
+  // http://freezone.google.com/*
+  // http://www.freezone.google.com/*
+  // http://accounts.freezone.google.com/*
+  // http://mail.freezone.google.com/*
+  // http://plus.freezone.google.com/*
+  // http://search.freezone.google.com/*
+  AddHostPatternToBypass("*freezone.google.com");

[nyquist, 2013/09/04 02:20:15]

Seems like this pattern might match too much. Could this be expressed as two
rules? Something like:

AddHostPatternToBypass("freezone.google.com");
AddHostPatternToBypass("*.freezone.google.com");

[bengr, 2013/09/05 02:03:49]

I've added a TODO.

On 2013/09/04 02:20:15, nyquist wrote:

+  // http://freezone.googleusercontent.com/*
+  AddHostPatternToBypass("freezone.googleusercontent.com");
+  // http://g.co/gms/*
+  AddURLPatternToBypass("http://g.co/gms/*");
+  // http://g.co/freezone*
+  AddURLPatternToBypass("http://g.co/freezone*");
+  // Check for proxy availability
+  AddURLPatternToBypass(GetProxyCheckURL());
+}
+
+void DataReductionProxySettingsAndroid::AddURLPatternToBypass(
+    const std::string& pattern) {
+  AddPatternToBypass("url", pattern);
+}
+
+void DataReductionProxySettingsAndroid::AddHostPatternToBypass(
+    const std::string& pattern) {
+  AddPatternToBypass("host", pattern);
+}
+
+void DataReductionProxySettingsAndroid::AddPatternToBypass(
+    const std::string& url_or_host,
+    const std::string& pattern) {
+  bypass_rules_.push_back(
+      StringPrintf("shExpMatch(%s, \"%s\")",
+                   url_or_host.c_str(), pattern.c_str()));
+}
+
+void DataReductionProxySettingsAndroid::AddHostToBypass(
+    const std::string& host) {
+  bypass_rules_.push_back(
+      StringPrintf("host == \"%s\"", host.c_str()));
+}
+
+void DataReductionProxySettingsAndroid::AddURLSubstringToBypass(
+    const std::string& url,
+    int from,
+    int to) {
+  bypass_rules_.push_back(
+      StringPrintf("url.substring(%d, %d) == \"%s\"", from, to, url.c_str()));
+}
+
+bool DataReductionProxySettingsAndroid::IsDataReductionProxyAvailable() {
+  return (base::FieldTrialList::FindFullName(
+      "DataCompressionProxyRollout") == "Enabled");
+}
+
+bool DataReductionProxySettingsAndroid::IsDataReductionProxyPromoAvailable() {
+  return (IsDataReductionProxyAvailable() && base::FieldTrialList::FindFullName(
+      "DataCompressionProxyPromoVisibility") == "Enabled");
+}
+
+std::string DataReductionProxySettingsAndroid::GetProxyPacScript() {
+  std::string bypass_clause = "(" + JoinString(bypass_rules_, ") || (") + ")";
+
+  // We want to fall back to direct loading when the proxy is unavailable and
+  // only process HTTP traffic, so we concoct a PAC configuration
+  // accordingly. (With a statically configured proxy, proxy failures will
+  // simply result in a connection error presented to users.)
+
+  std::string pac = "function FindProxyForURL(url, host) {"
+      "  if (" + bypass_clause + ") {"
+      "    return \"DIRECT\";"
+      "  } "
+      "  if (url.substring(0, 5) == \"http:\") {"
+      "    return \"HTTPS " + GetDataReductionProxyOriginHostPort() +
+      "; DIRECT\";"
+      "  }"
+      "  return \"DIRECT\";"
+      "}";
+  return pac;
+}
+
+PrefService* DataReductionProxySettingsAndroid::GetPrefService() {
+  return g_browser_process->profile_manager()->GetDefaultProfile()->
+      GetOriginalProfile()->GetPrefs();
+}
+
+std::string
+DataReductionProxySettingsAndroid::GetDataReductionProxyOriginHostPort() {
+  std::string spdy_proxy = "";
+
+  PrefService* local_state = g_browser_process->local_state();
+  if (local_state->HasPrefPath(prefs::kSpdyProxyAuthOrigin)) {
+    spdy_proxy = local_state->GetString(prefs::kSpdyProxyAuthOrigin);
+  } else {
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+    spdy_proxy = SPDY_PROXY_AUTH_ORIGIN;
+#endif
+  }
+
+  if (!spdy_proxy.empty()) {
+    // Remove a trailing slash from the proxy string if one exists as well as
+    // leading HTTPS scheme.
+    unsigned len = spdy_proxy.size();
+    if (len > 0 && spdy_proxy[len - 1] == '/') {
+      spdy_proxy.erase(len - 1, 1);
+    }
+    std::string https_scheme("https://");
+    if (len > https_scheme.length() &&
+        spdy_proxy.compare(0, https_scheme.length(), https_scheme) == 0) {
+      spdy_proxy.erase(0, https_scheme.length());
+    }
+  } else {
+    DLOG(ERROR) << "A SPDY proxy has not been set.";
+  }
+  return spdy_proxy;
+}
+
+void DataReductionProxySettingsAndroid::ResetDataReductionStatistics() {
+  PrefService* prefs = g_browser_process->local_state();
+  if (!prefs)
+    return;
+  ListPrefUpdate original_update(prefs, prefs::kDailyHttpOriginalContentLength);
+  ListPrefUpdate received_update(prefs, prefs::kDailyHttpReceivedContentLength);
+  original_update->Clear();
+  received_update->Clear();
+  for (size_t i = 0; i < kNumDaysInHistory; ++i) {
+    original_update->AppendString(base::Int64ToString(0));
+    received_update->AppendString(base::Int64ToString(0));
+  }
+}
+
+void DataReductionProxySettingsAndroid::InitDataReductionProxySettings(
+    JNIEnv* env,
+    jobject obj) {
+  // Disable the proxy is it's not meant to be available.
+  if (!IsDataReductionProxyAvailable()) return;
+
+  PrefService* prefs = GetPrefService();
+  CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  bool spdy_proxy_enabled = prefs->GetBoolean(prefs::kSpdyProxyAuthEnabled);
+
+  // Setting the kEnableSpdyProxyAuth switch has the same effect as enabling
+  // the feature via settings, in that once set, the preference will be sticky
+  // across instances of Chrome. Disabling the feature can only be done through
+  // the settings menu.
+  UMA_HISTOGRAM_ENUMERATION("SpdyProxyAuth.State", CHROME_STARTUP,
+                            NUM_SPDY_PROXY_AUTH_STATE);
+  if (command_line.HasSwitch(switches::kEnableSpdyProxyAuth) ||
+      spdy_proxy_enabled) {
+    SetDataReductionProxyEnabled(NULL, NULL, true);
+  } else {
+    LOG(WARNING) << "SPDY proxy OFF at startup.";

[nyquist, 2013/09/04 02:20:15]

DLOG?

[bengr, 2013/09/05 02:03:49]

We need this to be a WARNING so that it is included with user feedback.

On 2013/09/04 02:20:15, nyquist wrote:

+  }
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyEnabled(
+    JNIEnv* env, jobject obj) {
+  return GetPrefService()->GetBoolean(prefs::kSpdyProxyAuthEnabled);
+}
+
+void DataReductionProxySettingsAndroid::SetDataReductionProxyEnabled(
+    JNIEnv* env,
+    jobject obj,
+    jboolean enabled) {
+
+  // Disable the proxy is it's not meant to be available.
+  if (!IsDataReductionProxyAvailable()) return;
+
+  // Check if the proxy has been disabled explicitly by the carrier.
+  CheckDataReductionProxyIsAvailable(GetProxyCheckURL());
+
+  PrefService* prefs = GetPrefService();
+
+  prefs->SetBoolean(prefs::kSpdyProxyAuthEnabled, enabled);
+
+  if (enabled && !prefs->GetBoolean(prefs::kSpdyProxyAuthWasEnabledBefore)) {
+    prefs->SetBoolean(prefs::kSpdyProxyAuthWasEnabledBefore, true);
+    ResetDataReductionStatistics();
+  }
+
+  std::string spdy_proxy_origin = GetDataReductionProxyOriginHostPort();
+
+  // Configure use of the data reduction proxy if it is enabled and the proxy
+  // origin is non-empty.
+  enabled_by_user_= enabled && spdy_proxy_origin != "";
+  SetProxyPac(enabled_by_user_, !env);
+
+}
+
+void DataReductionProxySettingsAndroid::SetProxyPac(bool enable_spdy_proxy,
+                                                bool at_startup) {
+  PrefService* prefs = GetPrefService();
+  DCHECK(prefs);
+  // Keys duplicated from proxy_config_dictionary.cc

[nyquist, 2013/09/04 02:20:15]

Add TODO about moving them to proxy_config_dictionary.h and reuse them here, now
that it all lives upstream?

[bengr, 2013/09/05 02:03:49]

Done.

+  const char kProxyMode[] = "mode";
+  const char kProxyPacURL[] = "pac_url";
+  const char kAtStartup[] = "at startup";
+  const char kByUser[] = "by user action";
+
+  DictionaryPrefUpdate update(prefs, prefs::kProxy);
+  DictionaryValue* dict = update.Get();
+  if (enable_spdy_proxy) {
+    LOG(WARNING) << "SPDY proxy ON " << (at_startup ? kAtStartup : kByUser);
+    // Convert to a data URI and update the PAC settings.
+    std::string base64_pac;
+    base::Base64Encode(GetProxyPacScript(), &base64_pac);
+
+    dict->SetString(kProxyPacURL,
+                    "data:application/x-ns-proxy-autoconfig;base64," +
+                    base64_pac);
+    dict->SetString(kProxyMode,
+                    ProxyModeToString(ProxyPrefs::MODE_PAC_SCRIPT));
+
+    if (at_startup) {
+      UMA_HISTOGRAM_ENUMERATION("SpdyProxyAuth.State",
+                                SPDY_PROXY_AUTH_ON_AT_STARTUP,
+                                NUM_SPDY_PROXY_AUTH_STATE);
+    } else if (!has_turned_on_) {
+      // SPDY proxy auth is turned on by user action for the first time in
+      // this session.
+      UMA_HISTOGRAM_ENUMERATION("SpdyProxyAuth.State",
+                                SPDY_PROXY_AUTH_ON_BY_USER,
+                                NUM_SPDY_PROXY_AUTH_STATE);
+      has_turned_on_ = true;
+    }
+  } else {
+    LOG(WARNING) << "SPDY proxy OFF " << (at_startup ? kAtStartup : kByUser);
+    dict->SetString(kProxyMode, ProxyModeToString(ProxyPrefs::MODE_SYSTEM));
+    dict->SetString(kProxyPacURL, "");
+
+    if (!at_startup && !has_turned_off_) {
+      UMA_HISTOGRAM_ENUMERATION("SpdyProxyAuth.State",
+                                SPDY_PROXY_AUTH_OFF_BY_USER,
+                                NUM_SPDY_PROXY_AUTH_STATE);
+      has_turned_off_ = true;
+    }
+  }
+}
+
+void DataReductionProxySettingsAndroid::OnIPAddressChanged() {
+  CheckDataReductionProxyIsAvailable(GetProxyCheckURL());
+}
+
+void DataReductionProxySettingsAndroid::CheckDataReductionProxyIsAvailable(
+    std::string url) {
+  fetcher_.reset(net::URLFetcher::Create(0, GURL(url),
+                                         net::URLFetcher::GET, this));
+  fetcher_->SetLoadFlags(net::LOAD_DISABLE_CACHE |
+                         net::LOAD_IGNORE_ALL_CERT_ERRORS);
+  Profile* profile = g_browser_process->profile_manager()->
+      GetDefaultProfile();
+  fetcher_->SetRequestContext(profile->GetRequestContext());
+  // Configure to max_retries at most kMaxRetries times for 5xx errors.
+  static const int kMaxRetries = 5;
+  fetcher_->SetMaxRetriesOn5xx(kMaxRetries);
+  fetcher_->Start();
+}
+
+void DataReductionProxySettingsAndroid::OnURLFetchComplete(
+    const net::URLFetcher* source) {
+  net::URLRequestStatus status = source->GetStatus();
+  if (status.status() == net::URLRequestStatus::FAILED &&
+      status.error() == net::ERR_INTERNET_DISCONNECTED) {
+    return;
+  }
+
+  std::string response;
+  source->GetResponseAsString(&response);
+
+  if ("OK" == response.substr(0, 2)) {
+    DVLOG(1) << "The data reduction proxy is not blocked.";
+
+    // The user enabled the proxy, but sometime previously in the session,
+    // the carrier had disabled the proxy. Now that the carrier is enabling
+    // it, configure it to the user's desires.
+    if (enabled_by_user_ && disabled_by_carrier_)
+      SetProxyPac(true, false);
+    disabled_by_carrier_ = false;
+    return;
+  }
+  DVLOG(1) << "The data reduction proxy is blocked.";
+  // Disable the proxy.
+  if (enabled_by_user_ && !disabled_by_carrier_)
+    SetProxyPac(false, false);
+  disabled_by_carrier_ = true;
+}
+
+std::string DataReductionProxySettingsAndroid::GetProxyCheckURL() {
+  std::string origin = "http://" + GetDataReductionProxyOriginHostPort();
+  GURL gurl(origin);
+  return gurl.scheme() + "://enabled." + gurl.host() + gurl.path() + "connect";
+}
+
+void DataReductionProxySettingsAndroid::CheckDataReductionProxy(
+    JNIEnv* env, jobject obj) {
+  CheckDataReductionProxyIsAvailable(GetProxyCheckURL());
+}
+
+ScopedJavaLocalRef<jlongArray>
+DataReductionProxySettingsAndroid::GetDailyContentLengths(
+    JNIEnv* env, const char* pref_name) {
+ jlongArray result = env->NewLongArray(kNumDaysInHistory);
+  PrefService* local_state = g_browser_process->local_state();
+  if (!local_state)
+    return ScopedJavaLocalRef<jlongArray>(env, result);
+
+  const ListValue* list_value = local_state->GetList(pref_name);
+  if (list_value->GetSize() != kNumDaysInHistory)
+    return ScopedJavaLocalRef<jlongArray>(env, result);
+
+  jlong jval[kNumDaysInHistory];
+  for (size_t i = 0; i < kNumDaysInHistory; ++i) {
+    int64 val = 0;
+    std::string pref_value;
+    bool rv = list_value->GetString(i, &pref_value);
+    DCHECK(rv);
+    if (rv) {
+      rv = base::StringToInt64(pref_value, &val);
+      DCHECK(rv);
+    }
+    jval[i] = val;
+  }
+  env->SetLongArrayRegion(result, 0, kNumDaysInHistory, jval);
+  return ScopedJavaLocalRef<jlongArray>(env, result);
+}
+
+ScopedJavaLocalRef<jlongArray>
+DataReductionProxySettingsAndroid::GetDailyOriginalContentLengths(
+    JNIEnv* env, jobject obj) {
+  return GetDailyContentLengths(env, prefs::kDailyHttpOriginalContentLength);
+}
+
+ScopedJavaLocalRef<jlongArray>
+DataReductionProxySettingsAndroid::GetDailyReceivedContentLengths(
+    JNIEnv* env, jobject obj) {
+  return GetDailyContentLengths(env, prefs::kDailyHttpReceivedContentLength);
+}
+
+void DataReductionProxySettingsAndroid::GetContentLengths(
+    int days,
+    int64* original_content_length,
+    int64* received_content_length,
+    int64* last_update_time) {
+  PrefService* local_state = g_browser_process->local_state();
+  if (!local_state) {
+    *original_content_length = 0L;
+    *received_content_length = 0L;
+    *last_update_time = 0L;
+    return;
+  }
+
+  const ListValue* original_list =
+      local_state->GetList(prefs::kDailyHttpOriginalContentLength);
+  const ListValue* received_list =
+      local_state->GetList(prefs::kDailyHttpReceivedContentLength);
+  int64 last_update_internal =
+      local_state->GetInt64(prefs::kDailyHttpContentLengthLastUpdateDate);
+
+  if (original_list->GetSize() != kNumDaysInHistory ||
+      received_list->GetSize() != kNumDaysInHistory) {
+    *original_content_length = 0L;
+    *received_content_length = 0L;
+    *last_update_time = 0L;
+    return;
+  }
+
+  int64 orig = 0L;
+  int64 recv = 0L;
+  DCHECK_GE(static_cast<int>(kNumDaysInHistory), days);
+  DCHECK_LE(0, days);
+  // We include days from the end of the list going backwards.
+  for (int i = 0; i < days; ++i) {
+    int read_index = kNumDaysInHistory - 1 - i;
+    std::string result("0");
+    int64 val;
+    if (original_list->GetString(read_index, &result)) {
+      if (base::StringToInt64(result, &val))
+        orig +=val;
+      else
+        DCHECK(false);
+    } else {
+      DCHECK(false);
+    }
+    if (received_list->GetString(read_index, &result)) {
+      if (base::StringToInt64(result, &val))
+        recv +=val;
+      else
+        DCHECK(false);
+    } else {
+      DCHECK(false);
+    }
+  }
+  *original_content_length = orig;
+  *received_content_length = recv;
+  *last_update_time = last_update_internal;
+}
+
+static jint Init(JNIEnv* env, jobject obj) {
+  DataReductionProxySettingsAndroid* settings =
+      new DataReductionProxySettingsAndroid(env, obj);
+  return reinterpret_cast<jint>(settings);
+}
+
+// static
+bool DataReductionProxySettingsAndroid::Register(JNIEnv* env) {
+  bool register_natives_impl_result = RegisterNativesImpl(env);
+  return register_natives_impl_result;
+}