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/bind.h"
+#include "base/command_line.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
+#include "base/prefs/pref_change_registrar.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/host_port_pair.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::FieldTrialList;
+using base::StringPrintf;
+
+
+namespace {
+
+// The C++ definition of enum SpdyProxyAuthState defined in
+// tools/histograms/histograms.xml.
+// New values should be added at the end before |NUM_SPDY_PROXY_AUTH_STATE|

[mmenke, 2013/09/17 20:25:25]

nit:  +period.

[bengr, 2013/09/18 22:15:26]

Done.

+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
+};
+
+bool IsProxyOriginSetOnCommandLine() {
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kSpdyProxyAuthOrigin)) {
+    return true;
+  }
+  return false;
+}
+
+bool IsProxyAllowed() {
+  return IsProxyOriginSetOnCommandLine() ||
+      (FieldTrialList::FindFullName("DataCompressionProxyRollout") ==
+          "Enabled");
+}
+
+bool IsProxyPromoAllowed() {
+  return IsProxyOriginSetOnCommandLine() ||
+      (IsProxyAllowed() &&
+          FieldTrialList::FindFullName("DataCompressionProxyPromoVisibility") ==
+              "Enabled");
+}
+
+int64 GetInt64PrefValue(const ListValue& list_value, size_t index) {
+  int64 val = 0;
+  std::string pref_value;
+  bool rv = list_value.GetString(index, &pref_value);
+  DCHECK(rv);
+  if (rv) {
+    rv = base::StringToInt64(pref_value, &val);
+    DCHECK(rv);
+  }
+  return val;
+}
+
+std::string GetProxyCheckURL(){
+  if (!IsProxyAllowed())
+    return std::string();
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kDataReductionProxyProbeURL)) {
+    return command_line.GetSwitchValueASCII(switches::kSpdyProxyAuthOrigin);

[mmenke, 2013/09/17 20:25:25]

switches::kDataReductionProxyProbeURL?

[bengr, 2013/09/18 22:15:26]

Done. (Sorry, I caught this one after uploading and forgot to upload again.)

+  }
+#if defined(DATA_REDUCTION_PROXY_PROBE_URL)
+  return DATA_REDUCTION_PROXY_PROBE_URL;
+#else
+  return std::string();
+#endif
+}
+
+}  // namespace
+
+
+DataReductionProxySettingsAndroid::DataReductionProxySettingsAndroid(
+    JNIEnv* env, jobject obj)
+    : has_turned_on_(false),
+      has_turned_off_(false),
+      disabled_by_carrier_(false),
+      enabled_by_user_(false) {
+}
+
+DataReductionProxySettingsAndroid::~DataReductionProxySettingsAndroid() {
+}
+
+void DataReductionProxySettingsAndroid::InitDataReductionProxySettings(
+    JNIEnv* env,
+    jobject obj) {
+  // Disable the proxy if it is not allowed to be used.
+  if (!IsProxyAllowed())
+    return;
+
+  pref_change_registrar_.Init(GetOriginalProfilePrefs());
+  pref_change_registrar_.Add(
+      prefs::kSpdyProxyAuthEnabled,
+      base::Bind(&DataReductionProxySettingsAndroid::OnProxyEnabledPrefChange,
+                 base::Unretained(this)));

[mmenke, 2013/09/17 20:25:25]

Rather than use both a registrar and a pref lookup, you should just use a
BooleanPrefMember.  It will basically get rid of every other use of
kSpdyProxyAuthEnabled in this file.  It reduces redundant code, and protects a
bit against copying/pasting the wrong pref string.

Note that calling BooleanPrefMember::SetValue won't call back into |this|, to
prevent re-entrancy, so you'll need to call the onchange function directly, I
believe.  I think that's a little cleaner than relying on non-obvious
re-entrancy, anyways.

[bengr, 2013/09/18 22:15:26]

Done.

+
+  AddDefaultProxyBypassRules();
+  net::NetworkChangeNotifier::AddIPAddressObserver(this);
+
+  PrefService* prefs = GetOriginalProfilePrefs();
+  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) {

[mmenke, 2013/09/17 20:25:25]

nit:  Checking spdy_proxy_enabled_ first is marginally faster.  Performance
doesn't really matter here, of course, but still...Seems like the more expensive
check should go second.

[bengr, 2013/09/18 22:15:26]

Done.

+    MaybeActivateDataReductionProxy(true);
+  } else {
+    LOG(WARNING) << "SPDY proxy OFF at startup.";
+  }
+}
+
+void DataReductionProxySettingsAndroid::BypassHostPattern(
+    JNIEnv* env, jobject obj, jstring pattern) {
+  AddHostPatternToBypass(ConvertJavaStringToUTF8(env, pattern));
+}
+void DataReductionProxySettingsAndroid::BypassURLPattern(
+    JNIEnv* env, jobject obj, jstring pattern) {
+  AddURLPatternToBypass(ConvertJavaStringToUTF8(env, pattern));
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyAllowed(
+    JNIEnv* env, jobject obj) {
+  return IsProxyAllowed();
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyPromoAllowed(
+    JNIEnv* env, jobject obj) {
+  return IsProxyPromoAllowed();
+}
+
+ScopedJavaLocalRef<jstring>
+DataReductionProxySettingsAndroid::GetDataReductionProxyOrigin(
+    JNIEnv* env, jobject obj) {
+  return ConvertUTF8ToJavaString(env, GetDataReductionProxyOriginInternal());
+}
+
+ScopedJavaLocalRef<jstring>
+DataReductionProxySettingsAndroid::GetDataReductionProxyAuth(
+    JNIEnv* env, jobject obj) {
+  if (!IsProxyAllowed())
+    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(switches::kSpdyProxyAuthValue)) {
+      return ConvertUTF8ToJavaString(
+          env,
+          command_line.GetSwitchValueASCII(switches::kSpdyProxyAuthValue));
+    }
+    return ConvertUTF8ToJavaString(env, std::string());

[mmenke, 2013/09/17 20:25:25]

Think this is worth a comment (Just something along the lines of "Don't expose
SPDY_PROXY_AUTH_VALUE to a proxy passed in via the command line").

[bengr, 2013/09/18 22:15:26]

Done.

+  }
+#if defined(SPDY_PROXY_AUTH_VALUE)
+  return ConvertUTF8ToJavaString(env, SPDY_PROXY_AUTH_VALUE);
+#else
+  return ConvertUTF8ToJavaString(env, std::string());
+#endif
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyEnabled(
+    JNIEnv* env, jobject obj) {
+  return GetOriginalProfilePrefs()->GetBoolean(prefs::kSpdyProxyAuthEnabled);
+}
+
+jboolean DataReductionProxySettingsAndroid::IsDataReductionProxyManaged(
+    JNIEnv* env, jobject obj) {
+  return GetOriginalProfilePrefs()->IsManagedPreference(
+      prefs::kSpdyProxyAuthEnabled);
+}
+
+void DataReductionProxySettingsAndroid::SetDataReductionProxyEnabled(

[mmenke, 2013/09/17 20:25:25]

Are there already Java functions to set preferences directly?  Not strongly
opposed to this, just wondering if there's a preferable way of doing it.

[bengr, 2013/09/18 22:15:26]

This is how Chrome for Android does things.

+    JNIEnv* env,
+    jobject obj,
+    jboolean enabled) {
+  // Prevent configuring the proxy when it is not allowed to be used.
+  if (!IsProxyAllowed())
+    return;
+
+  PrefService* prefs = GetOriginalProfilePrefs();
+  prefs->SetBoolean(prefs::kSpdyProxyAuthEnabled, enabled);
+}
+
+jlong DataReductionProxySettingsAndroid::GetDataReductionLastUpdateTime(
+    JNIEnv* env, jobject obj) {
+  PrefService* local_state = GetLocalStatePrefs();
+  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;
+  GetContentLengthsInternal(spdyproxy::kNumDaysInHistorySummary,
+                            &original_content_length,
+                            &received_content_length, &last_update_internal);
+
+  return Java_ContentLengths_create(env,
+                                    original_content_length,
+                                    received_content_length);
+}
+
+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);
+}
+
+// static
+bool DataReductionProxySettingsAndroid::Register(JNIEnv* env) {
+  bool register_natives_impl_result = RegisterNativesImpl(env);
+  return register_natives_impl_result;
+}
+
+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.";
+
+    if (enabled_by_user_ && disabled_by_carrier_) {
+      // The user enabled the proxy, but sometime previously in the session,
+      // the network operator had blocked the proxy. Now that the network
+      // operator is unblocking it, configure it to the user's desires.
+      SetProxyPac(true, false);
+    }
+    disabled_by_carrier_ = false;
+    return;
+  }
+  DVLOG(1) << "The data reduction proxy is blocked.";
+
+  if (enabled_by_user_ && !disabled_by_carrier_) {
+    // Disable the proxy.
+    SetProxyPac(false, false);
+  }
+  disabled_by_carrier_ = true;
+}
+
+void DataReductionProxySettingsAndroid::OnIPAddressChanged() {
+  if (enabled_by_user_)

[mmenke, 2013/09/17 20:25:25]

DCHECK(IsProxyAllowed())?  We should maintain some sort of invariant if
!IsProxyAllowed(), and the simplest seems to be that if !IsProxyAllowed(), then
enabled_by_user_ is always false, and we don't run any probes.

[bengr, 2013/09/18 22:15:26]

Done.

+    ProbeWhetherDataReductionProxyIsAvailable();
+}
+
+void DataReductionProxySettingsAndroid::OnProxyEnabledPrefChange() {

[mmenke, 2013/09/17 20:25:25]

Should we just exit of not Allowed?

[mmenke, 2013/09/17 21:51:51]

Err.... Or "kEnableSpdyProxyAuth" is set - either the pref or the command line
flag.  Separating out "enabled" and "allowed" seems really weird to me.

[bengr, 2013/09/18 22:15:26]

Done.

[bengr, 2013/09/18 22:15:26]

One reason to separate is for the UI. I.e., we shouldn't show the UI at all if
not part of the field trial, irrespective of whether the pref is set to enabled.
I thought a bit about creating an enum with states: DISALLOWED, DISABLED,
ENABLED, DISABLED_VIA_PROBE_FAILURE, but I don't think it would simplify things.
I'm ok with leaving the code as is, but would entertain suggestions.

+  MaybeActivateDataReductionProxy(false);
+}
+
+void DataReductionProxySettingsAndroid::AddDefaultProxyBypassRules() {
+  // localhost
+  AddHostToBypass("localhost");
+  AddHostPatternToBypass("localhost.*");
+  AddHostToBypass("127.0.0.1");
+  AddHostToBypass("[::1]");

[mmenke, 2013/09/17 20:25:25]

I believe you can use about:net-internals#events.   Calls to alert() in
Javascript should show up in the HTTP_STREAM_REQUEST events that resulted in the
call (Look for PAC_JAVASCRIPT_ALERT).

That having been said, looking at the code, I think it should be "::1", rather
than "[::1]".  See
https://code.google.com/p/chromium/codesearch#chromium/src/net/proxy/proxy_re....
 Could also just ask eroman.

[bengr, 2013/09/18 22:15:26]

Done.

+  // TODO(bengr): revisit 192.168.*,  10.*, 172.16.0.0 - 172.31.255.255. The
+  // concern was that adding these and other rules would add to the processing
+  // time.
+
+  // TODO(bengr): See http://crbug.com/169959. For some reason the data
+  // reduction proxy is breaking the omnibox SearchProvider.  Remove this rule
+  // when this is fixed.
+  AddURLPatternToBypass("http://www.google.com/complete/search*");
+
+  // Check for proxy availability
+  std::string proxy_check_url = GetProxyCheckURL();
+  if (!proxy_check_url.empty()) {
+    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()));
+}
+
+PrefService* DataReductionProxySettingsAndroid::GetOriginalProfilePrefs() {
+  return g_browser_process->profile_manager()->GetDefaultProfile()->
+      GetOriginalProfile()->GetPrefs();
+}
+
+PrefService* DataReductionProxySettingsAndroid::GetLocalStatePrefs() {
+  return g_browser_process->local_state();
+}
+
+std::string
+DataReductionProxySettingsAndroid::GetDataReductionProxyOriginInternal() {

[mmenke, 2013/09/17 20:25:25]

Looks like this function and the next one can be put in the anonymous namespace.

[bengr, 2013/09/18 22:15:26]

Done.

+  if (!IsProxyAllowed())
+    return std::string();

[mmenke, 2013/09/17 20:25:25]

Is this default behavior needed?  Doesn't seem like it matters in the not
allowed case.

[bengr, 2013/09/18 22:15:26]

Done.

+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kSpdyProxyAuthOrigin)) {
+    return command_line.GetSwitchValueASCII(switches::kSpdyProxyAuthOrigin);
+  }
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
+  return SPDY_PROXY_AUTH_ORIGIN;
+#else
+  return std::string();
+#endif
+}
+
+std::string
+DataReductionProxySettingsAndroid::GetDataReductionProxyOriginHostPort() {
+  std::string spdy_proxy = GetDataReductionProxyOriginInternal();
+  if (spdy_proxy.empty()) {
+    DLOG(ERROR) << "A SPDY proxy has not been set.";
+    return spdy_proxy;
+  }
+  // Remove a trailing slash from the proxy string if one exists as well as
+  // leading HTTPS scheme.
+  return net::HostPortPair::FromURL(GURL(spdy_proxy)).ToString();
+}
+
+void DataReductionProxySettingsAndroid::ResetDataReductionStatistics() {
+  PrefService* prefs = GetLocalStatePrefs();
+  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 < spdyproxy::kNumDaysInHistory; ++i) {
+    original_update->AppendString(base::Int64ToString(0));
+    received_update->AppendString(base::Int64ToString(0));
+  }
+}
+
+void DataReductionProxySettingsAndroid::MaybeActivateDataReductionProxy(
+    bool at_startup) {
+  PrefService* prefs = GetOriginalProfilePrefs();
+  bool enabled = prefs->GetBoolean(prefs::kSpdyProxyAuthEnabled);
+
+  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_ && !disabled_by_carrier_, at_startup);
+
+  // Check if the proxy has been disabled explicitly by the carrier.
+  if (enabled_by_user_)
+    ProbeWhetherDataReductionProxyIsAvailable();
+}
+
+void DataReductionProxySettingsAndroid::SetProxyPac(bool enable_spdy_proxy,
+                                                    bool at_startup) {
+  PrefService* prefs = GetOriginalProfilePrefs();
+  DCHECK(prefs);
+  // Keys duplicated from proxy_config_dictionary.cc
+  // TODO(bengr): Move these to proxy_config_dictionary.h and reuse them here.
+  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;
+    }
+  }
+}
+
+ScopedJavaLocalRef<jlongArray>
+DataReductionProxySettingsAndroid::GetDailyContentLengths(
+    JNIEnv* env, const char* pref_name) {
+  jlongArray result = env->NewLongArray(spdyproxy::kNumDaysInHistory);
+  PrefService* local_state = GetLocalStatePrefs();
+  if (!local_state)
+    return ScopedJavaLocalRef<jlongArray>(env, result);
+
+  const ListValue* list_value = local_state->GetList(pref_name);
+  if (list_value->GetSize() != spdyproxy::kNumDaysInHistory)
+    return ScopedJavaLocalRef<jlongArray>(env, result);
+
+  jlong jval[spdyproxy::kNumDaysInHistory];
+  for (size_t i = 0; i < spdyproxy::kNumDaysInHistory; ++i) {
+    jval[i] = GetInt64PrefValue(*list_value, i);
+  }
+  env->SetLongArrayRegion(result, 0, spdyproxy::kNumDaysInHistory, jval);
+  return ScopedJavaLocalRef<jlongArray>(env, result);
+}
+
+void DataReductionProxySettingsAndroid::GetContentLengthsInternal(
+    unsigned int days,
+    int64* original_content_length,
+    int64* received_content_length,
+    int64* last_update_time) {
+  DCHECK_LE(days, spdyproxy::kNumDaysInHistory);
+  PrefService* local_state = GetLocalStatePrefs();
+  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);

[mmenke, 2013/09/17 20:25:25]

Seems like we don't get anything from having the temporary here - can just move
the call down when setting *last_update_time.

[bengr, 2013/09/18 22:15:26]

Done.

+
+  if (original_list->GetSize() != spdyproxy::kNumDaysInHistory ||
+      received_list->GetSize() != spdyproxy::kNumDaysInHistory) {
+    *original_content_length = 0L;
+    *received_content_length = 0L;
+    *last_update_time = 0L;
+    return;
+  }
+
+  int64 orig = 0L;
+  int64 recv = 0L;
+  // We include days from the end of the list going backwards.
+  for (unsigned int i = 0; i < days; ++i) {
+    int read_index = spdyproxy::kNumDaysInHistory - 1 - i;
+    std::string result;
+    orig += GetInt64PrefValue(*original_list, read_index);
+    recv += GetInt64PrefValue(*received_list, read_index);
+  }
+  *original_content_length = orig;
+  *received_content_length = recv;
+  *last_update_time = last_update_internal;
+}
+
+net::URLFetcher* DataReductionProxySettingsAndroid::GetURLFetcher() {
+  std::string url = GetProxyCheckURL();
+  if (url.empty())
+    return NULL;
+  fetcher_.reset(net::URLFetcher::Create(0, GURL(url),

[mmenke, 2013/09/17 20:25:25]

Since you aren't using TestUrlFetcherFactory, you should just get rid of the
first argument.

[bengr, 2013/09/18 22:15:26]

Done.

+                                         net::URLFetcher::GET, this));
+  fetcher_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
+  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);
+  return fetcher_.get();
+}
+
+void
+DataReductionProxySettingsAndroid::ProbeWhetherDataReductionProxyIsAvailable() {
+  net::URLFetcher* fetcher = GetURLFetcher();

[mmenke, 2013/09/17 20:25:25]

optional:  I think it would be much cleaner to change ownership semantics so
this is fetcher_.reset(GetURLFetcher()).

Could alternatively use TestUrlFetcherFactory instead, but since we're
subclassing for tests anyways, I don't think that gets us all that much.

[bengr, 2013/09/18 22:15:26]

Done.

+  if (fetcher)

[mmenke, 2013/09/17 20:25:25]

Since this can't happen, I think it's best not to be doing this check.  My
general opinion is if something logically can't happen, don't handle it.  If
something unexpected happens, it's better to crash and then debug it, than to
silently continue on in an unexpected state.

[bengr, 2013/09/18 22:15:26]

This could happen if the proxy check url is empty.

+    fetcher->Start();
+}
+
+// TODO(bengr): Replace with our own ProxyResolver.
+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) {"
+      " alert(\"Hello World\");"

[mmenke, 2013/09/17 20:25:25]

I assume this was just for testing?

[bengr, 2013/09/18 22:15:26]

Done.

+      "  if (" + bypass_clause + ") {"
+      "    return \"DIRECT\";"
+      "  } "
+      "  if (url.substring(0, 5) == \"http:\") {"

[mmenke, 2013/09/17 20:25:25]

I thought media bypassed flywheel?  Or is that done by using no PAC for the
media URL request context, rather than at the PAC level?

[bengr, 2013/09/18 22:15:26]

Media is bypassed using a proxy-bypass signal from the proxy.

+      "    return \"HTTPS " + GetDataReductionProxyOriginHostPort() +
+      "; DIRECT\";"
+      "  }"
+      "  return \"DIRECT\";"
+      "}";
+  return pac;
+}
+
+// Used by generated jni code.
+static jint Init(JNIEnv* env, jobject obj) {
+  DataReductionProxySettingsAndroid* settings =
+      new DataReductionProxySettingsAndroid(env, obj);
+  return reinterpret_cast<jint>(settings);
+}
+
+