Added probe to determine if data reduction proxy can be used

chrome/browser/net/spdyproxy/data_reduction_proxy_settings_unittest_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 "base/android/jni_android.h"
+#include "base/android/jni_string.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/base64.h"
+#include "base/command_line.h"
+#include "base/metrics/field_trial.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/pref_service.h"
+#include "base/prefs/testing_pref_service.h"
+#include "base/strings/string_number_conversions.h"
+#include "chrome/browser/net/spdyproxy/data_reduction_proxy_settings_android.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/metrics/variations/variations_util.h"
+#include "chrome/common/pref_names.h"
+#include "components/variations/entropy_provider.h"
+#include "net/url_request/test_url_fetcher_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+const char kDataReductionProxyOrigin[] = "https://foo:443/";
+const char kDataReductionProxyOriginHostPort[] = "foo:443";
+const char kDataReductionProxyAuth[] = "12345";
+
+const char kProbeURLWithOKResponse[] = "http://ok.org/";
+const char kProbeURLWithBadResponse[] = "http://bad.org/";
+const char kProbeURLWithNoResponse[] = "http://no.org/";
+
+class TestDataReductionProxySettingsAndroid
+    : public DataReductionProxySettingsAndroid {
+ public:
+  TestDataReductionProxySettingsAndroid(JNIEnv* env, jobject obj,
+                                        PrefService* profile_prefs,
+                                        PrefService* local_state_prefs)
+    : DataReductionProxySettingsAndroid(env, obj),
+      success_(false),
+      fake_fetcher_request_count_(0),
+      profile_prefs_for_testing_(profile_prefs),
+      local_state_prefs_for_testing_(local_state_prefs) {
+    InitPrefMembers();
+  }
+
+  // DataReductionProxySettingsAndroid implementation:
+  virtual net::URLFetcher* GetURLFetcher() OVERRIDE {
+    if (test_url_.empty())
+      return NULL;
+    net::URLFetcher* fetcher = new net::FakeURLFetcher(GURL(test_url_), this,
+                                                       response_, success_);
+    fake_fetcher_request_count_++;
+    return fetcher;
+  }
+
+  virtual PrefService* GetOriginalProfilePrefs() OVERRIDE {
+    return profile_prefs_for_testing_;
+  }
+  virtual PrefService* GetLocalStatePrefs() OVERRIDE {
+    return local_state_prefs_for_testing_;
+  }
+
+  void set_probe_result(const std::string& test_url,
+                        const std::string& response,
+                        bool success) {
+    test_url_ = test_url;
+    response_ = response;
+    success_ = success;
+  }
+
+  int fake_fetcher_request_count() {
+    return fake_fetcher_request_count_;
+  }
+
+ private:
+  std::string test_url_;
+  std::string response_;
+  bool success_;
+  int fake_fetcher_request_count_;
+  PrefService* profile_prefs_for_testing_;
+  PrefService* local_state_prefs_for_testing_;
+};
+
+class DataReductionProxySettingsAndroidTest : public testing::Test {
+ protected:
+  DataReductionProxySettingsAndroidTest() {
+    ResetFieldTrialList();
+  }
+
+  void ResetFieldTrialList() {
+     // Destroy the existing FieldTrialList before creating a new one to avoid
+     // a DCHECK.
+     field_trial_list_.reset();
+     field_trial_list_.reset(new base::FieldTrialList(
+         new metrics::SHA1EntropyProvider("foo")));
+     chrome_variations::testing::ClearAllVariationParams();
+   }
+
+  // Creates and activates a field trial.
+  static base::FieldTrial* CreateTestTrial(const std::string& name,
+                                           const std::string& group_name) {
+    base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
+        name, group_name);
+    trial->group();
+    return trial;
+  }
+
+  // testing::Test implementation:
+  virtual void SetUp() OVERRIDE {
+    CreateTestTrial("DataCompressionProxyRollout", "Enabled");
+    CreateTestTrial("DataCompressionProxyPromoVisibility", "Enabled");
+    CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+        switches::kSpdyProxyAuthOrigin, kDataReductionProxyOrigin);
+    CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+        switches::kSpdyProxyAuthValue, kDataReductionProxyAuth);
+
+    PrefRegistrySimple* registry = pref_service_.registry();
+    registry->RegisterListPref(prefs::kDailyHttpOriginalContentLength);
+    registry->RegisterListPref(prefs::kDailyHttpReceivedContentLength);
+    registry->RegisterInt64Pref(
+        prefs::kDailyHttpContentLengthLastUpdateDate, 0L);
+    registry->RegisterDictionaryPref(prefs::kProxy);
+    registry->RegisterBooleanPref(prefs::kSpdyProxyAuthEnabled, false);
+    registry->RegisterBooleanPref(prefs::kSpdyProxyAuthWasEnabledBefore, false);
+    settings_.reset(new TestDataReductionProxySettingsAndroid(NULL, NULL,
+                                                              &pref_service_,
+                                                              &pref_service_));
+    ListPrefUpdate original_update(&pref_service_,
+                                   prefs::kDailyHttpOriginalContentLength);
+    ListPrefUpdate received_update(&pref_service_,
+                                   prefs::kDailyHttpReceivedContentLength);
+    for (int64 i = 0; i < spdyproxy::kNumDaysInHistory; i++) {
+      original_update->Insert(0, new StringValue(base::Int64ToString(2 * i)));
+      received_update->Insert(0, new StringValue(base::Int64ToString(i)));
+    }
+    last_update_time_ = base::Time::Now().LocalMidnight();
+    pref_service_.SetInt64(
+        prefs::kDailyHttpContentLengthLastUpdateDate,
+        last_update_time_.ToInternalValue());
+  }
+
+  void CheckProxyPrefSetToDataReductionProxy(
+      const std::string& expected_pac_url) {
+    const DictionaryValue* dict = pref_service_.GetDictionary(prefs::kProxy);
+    std::string mode;
+    std::string pac_url;
+    dict->GetString("mode", &mode);
+    EXPECT_EQ(ProxyModeToString(ProxyPrefs::MODE_PAC_SCRIPT), mode);
+    dict->GetString("pac_url", &pac_url);
+    EXPECT_EQ(expected_pac_url, pac_url);
+  }
+  void CheckProxyPrefSetToSystem() {
+    const DictionaryValue* dict = pref_service_.GetDictionary(prefs::kProxy);
+    std::string mode;
+    std::string pac_url;
+    dict->GetString("mode", &mode);
+    EXPECT_EQ(ProxyModeToString(ProxyPrefs::MODE_SYSTEM), mode);
+    dict->GetString("pac_url", &pac_url);
+    EXPECT_EQ(std::string(), pac_url);
+  }
+
+  void CheckProbe(bool initially_enabled, const std::string& probe_url,
+                  const std::string& response, bool request_success,
+                  bool expected_enabled) {
+    settings_->AddDefaultProxyBypassRules();
+    std::string pac;
+    base::Base64Encode(settings_->GetProxyPacScript(), &pac);
+    std::string expected_pac_url =
+        "data:application/x-ns-proxy-autoconfig;base64," + pac;
+    pref_service_.SetBoolean(prefs::kSpdyProxyAuthEnabled, initially_enabled);
+    settings_->set_probe_result(probe_url, response, request_success);
+    settings_->MaybeActivateDataReductionProxy(false);
+    base::MessageLoop::current()->RunUntilIdle();
+    if (expected_enabled)
+      CheckProxyPrefSetToDataReductionProxy(expected_pac_url);
+    else
+      CheckProxyPrefSetToSystem();
+  }
+
+  TestingPrefServiceSimple pref_service_;
+  scoped_ptr<TestDataReductionProxySettingsAndroid> settings_;
+  base::Time last_update_time_;
+  // This is a singleton that will clear all set field trials on destruction.
+  scoped_ptr<base::FieldTrialList> field_trial_list_;
+};
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestGetDataReductionProxyOrigin) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  DataReductionProxySettingsAndroid::Register(env);
+  // SetUp() adds the origin to the command line, which should be returned here.
+  ScopedJavaLocalRef<jstring> result =
+      settings_->GetDataReductionProxyOrigin(env, NULL);
+  ASSERT_TRUE(result.obj());
+  const base::android::JavaRef<jstring>& str_ref = result;
+  EXPECT_EQ(kDataReductionProxyOrigin, ConvertJavaStringToUTF8(str_ref));
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestGetDataReductionProxyAuth) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  DataReductionProxySettingsAndroid::Register(env);
+  // SetUp() adds the auth string to the command line, which should be returned
+  // here.
+  ScopedJavaLocalRef<jstring> result =
+      settings_->GetDataReductionProxyAuth(env, NULL);
+  ASSERT_TRUE(result.obj());
+  const base::android::JavaRef<jstring>& str_ref = result;
+  EXPECT_EQ(kDataReductionProxyAuth, ConvertJavaStringToUTF8(str_ref));
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestBypassRules) {
+  // Confirm that the bypass rule functions generate the intended JavaScript
+  // code for the Proxy PAC.
+  settings_->AddURLPatternToBypass("http://foo.com/*");
+  settings_->AddHostPatternToBypass("bar.com");
+  settings_->AddHostToBypass("127.0.0.1");
+
+  std::string expected[] = {
+      "shExpMatch(url, \"http://foo.com/*\")",
+      "shExpMatch(host, \"bar.com\")",
+      "host == \"127.0.0.1\""
+  };
+
+  int i = 0;
+  for (std::vector<std::string>::iterator it = settings_->bypass_rules_.begin();
+       it != settings_->bypass_rules_.end(); ++it) {
+    EXPECT_EQ(expected[i++], *it);
+  }
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestIsProxyEnabledOrManaged) {
+  EXPECT_FALSE(settings_->IsDataReductionProxyEnabled(NULL, NULL));
+  EXPECT_FALSE(settings_->IsDataReductionProxyManaged(NULL, NULL));
+
+  pref_service_.SetBoolean(prefs::kSpdyProxyAuthEnabled, true);
+  EXPECT_TRUE(settings_->IsDataReductionProxyEnabled(NULL, NULL));
+  EXPECT_FALSE(settings_->IsDataReductionProxyManaged(NULL, NULL));
+
+  pref_service_.SetManagedPref(prefs::kSpdyProxyAuthEnabled,
+                               base::Value::CreateBooleanValue(true));
+  EXPECT_TRUE(settings_->IsDataReductionProxyEnabled(NULL, NULL));
+  EXPECT_TRUE(settings_->IsDataReductionProxyManaged(NULL, NULL));
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestSetProxyPac) {
+  settings_->AddDefaultProxyBypassRules();
+  std::string pac;
+  base::Base64Encode(settings_->GetProxyPacScript(), &pac);
+  std::string expected_pac_url =
+      "data:application/x-ns-proxy-autoconfig;base64," + pac;
+  // Test setting the PAC, without generating histograms.
+  settings_->has_turned_on_ = true;
+  settings_->SetProxyPac(true, false);
+  CheckProxyPrefSetToDataReductionProxy(expected_pac_url);
+
+  // Test disabling the PAC, without generating histograms.
+  settings_->has_turned_off_ = true;
+  settings_->SetProxyPac(false, false);
+  CheckProxyPrefSetToSystem();
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestGetDailyContentLengths) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  DataReductionProxySettingsAndroid::Register(env);
+  ScopedJavaLocalRef<jlongArray> result =
+      settings_->GetDailyContentLengths(env,
+                                        prefs::kDailyHttpOriginalContentLength);
+  ASSERT_TRUE(result.obj());
+
+  jsize java_array_len = env->GetArrayLength(result.obj());
+  ASSERT_EQ(static_cast<jsize>(spdyproxy::kNumDaysInHistory), java_array_len);
+
+  jlong value;
+  for (size_t i = 0; i < spdyproxy::kNumDaysInHistory; ++i) {
+    env->GetLongArrayRegion(result.obj(), i, 1, &value);
+    ASSERT_EQ(static_cast<long>(118 - (2 * i)), value);
+  }
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest,
+       TestResetDataReductionStatistics) {
+  int64 original_content_length;
+  int64 received_content_length;
+  int64 last_update_time;
+  settings_->ResetDataReductionStatistics();
+  settings_->GetContentLengthsInternal(spdyproxy::kNumDaysInHistory,
+                                       &original_content_length,
+                                       &received_content_length,
+                                       &last_update_time);
+  EXPECT_EQ(0L, original_content_length);
+  EXPECT_EQ(0L, received_content_length);
+  EXPECT_EQ(last_update_time_.ToInternalValue(), last_update_time);
+}
+
+
+TEST_F(DataReductionProxySettingsAndroidTest, TestContentLengthsInternal) {
+  int64 original_content_length;
+  int64 received_content_length;
+  int64 last_update_time;
+  settings_->GetContentLengthsInternal(spdyproxy::kNumDaysInHistory,
+                                       &original_content_length,
+                                       &received_content_length,
+                                       &last_update_time);
+  EXPECT_EQ(3540L, original_content_length);
+  EXPECT_EQ(1770L, received_content_length);
+  EXPECT_EQ(last_update_time_.ToInternalValue(), last_update_time);
+}
+
+TEST_F(DataReductionProxySettingsAndroidTest,
+       TestMaybeActivateDataReductionProxy) {
+  // TODO(bengr): Test enabling/disabling while a probe is outstanding.
+  base::MessageLoop loop(base::MessageLoop::TYPE_UI);
+  // The proxy is enabled initially.
+  // Request succeeded but with bad response, expect proxy to be disabled.
+  CheckProbe(true, kProbeURLWithBadResponse, "Bad", true, false);
+  // Request succeeded with valid response, expect proxy to be enabled.
+  CheckProbe(true, kProbeURLWithOKResponse, "OK", true, true);
+  // Request failed, expect proxy to be disabled.
+  CheckProbe(true, kProbeURLWithNoResponse, "", false, false);
+
+  // The proxy is disabled initially. Probes should not be emitted to change
+  // state.
+  EXPECT_EQ(3, settings_->fake_fetcher_request_count());
+  CheckProbe(false, kProbeURLWithOKResponse, "OK", true, false);
+  EXPECT_EQ(3, settings_->fake_fetcher_request_count());
+}
+