src/chrome/browser/net/chrome_network_data_saving_metrics_unittest.cc

   1 // Copyright 2013 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 "base/basictypes.h"
   6 #include "base/compiler_specific.h"
   7 #include "base/prefs/pref_registry_simple.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/prefs/scoped_user_pref_update.h"
  10 #include "base/prefs/testing_pref_service.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "chrome/browser/net/chrome_network_data_saving_metrics.h"
  13 #include "chrome/common/pref_names.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace {
  17
  18 #if defined(OS_ANDROID) || defined(OS_IOS)
  19 const size_t kNumDaysInHistory = 60;
  20
  21 int64 GetListPrefInt64Value(
  22     const base::ListValue& list_update, size_t index) {
  23   std::string string_value;
  24   EXPECT_TRUE(list_update.GetString(index, &string_value));
  25
  26   int64 value = 0;
  27   EXPECT_TRUE(base::StringToInt64(string_value, &value));
  28   return value;
  29 }
  30
  31 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
  32
  33 // Test UpdateContentLengthPrefs.
  34 class ChromeNetworkDataSavingMetricsTest : public testing::Test {
  35  protected:
  36   ChromeNetworkDataSavingMetricsTest() {}
  37
  38   virtual void SetUp() OVERRIDE {
  39     PrefRegistrySimple* registry = pref_service_.registry();
  40     registry->RegisterInt64Pref(prefs::kHttpReceivedContentLength, 0);
  41     registry->RegisterInt64Pref(prefs::kHttpOriginalContentLength, 0);
  42
  43 #if defined(OS_ANDROID) || defined(OS_IOS)
  44     registry->RegisterListPref(prefs::kDailyHttpOriginalContentLength);
  45     registry->RegisterListPref(prefs::kDailyHttpReceivedContentLength);
  46     registry->RegisterListPref(
  47         prefs::kDailyOriginalContentLengthWithDataReductionProxyEnabled);
  48     registry->RegisterListPref(
  49         prefs::kDailyContentLengthWithDataReductionProxyEnabled);
  50     registry->RegisterListPref(
  51         prefs::kDailyOriginalContentLengthViaDataReductionProxy);
  52     registry->RegisterListPref(
  53         prefs::kDailyContentLengthViaDataReductionProxy);
  54     registry->RegisterInt64Pref(
  55         prefs::kDailyHttpContentLengthLastUpdateDate, 0L);
  56 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
  57   }
  58
  59   TestingPrefServiceSimple pref_service_;
  60 };
  61
  62 TEST_F(ChromeNetworkDataSavingMetricsTest, TotalLengths) {
  63   const int64 kOriginalLength = 200;
  64   const int64 kReceivedLength = 100;
  65
  66   chrome_browser_net::UpdateContentLengthPrefs(
  67       kReceivedLength, kOriginalLength,
  68       false, false, &pref_service_);
  69   EXPECT_EQ(kReceivedLength,
  70             pref_service_.GetInt64(prefs::kHttpReceivedContentLength));
  71   EXPECT_EQ(kOriginalLength,
  72             pref_service_.GetInt64(prefs::kHttpOriginalContentLength));
  73
  74   // Record the same numbers again, and total lengths should be dobuled.
  75   chrome_browser_net::UpdateContentLengthPrefs(
  76       kReceivedLength, kOriginalLength,
  77       false, false, &pref_service_);
  78   EXPECT_EQ(kReceivedLength * 2,
  79             pref_service_.GetInt64(prefs::kHttpReceivedContentLength));
  80   EXPECT_EQ(kOriginalLength * 2,
  81             pref_service_.GetInt64(prefs::kHttpOriginalContentLength));
  82 }
  83
  84 #if defined(OS_ANDROID) || defined(OS_IOS)
  85
  86 // The initial last update time used in test. There is no leap second a few
  87 // days around this time used in the test.
  88 // Note: No time zone is specified. Local time will be assumed by
  89 // base::Time::FromString below.
  90 const char kLastUpdateTime[] = "Wed, 18 Sep 2013 03:45:26";
  91
  92 class ChromeNetworkDailyDataSavingMetricsTest
  93     : public ChromeNetworkDataSavingMetricsTest {
  94  protected:
  95   ChromeNetworkDailyDataSavingMetricsTest() {
  96     base::Time::FromString(kLastUpdateTime, &now_);
  97   }
  98
  99   virtual void SetUp() OVERRIDE {
 100     ChromeNetworkDataSavingMetricsTest::SetUp();
 101
 102     // Only create two lists in Setup to test that adding new lists is fine.
 103     CreatePrefList(prefs::kDailyHttpOriginalContentLength);
 104     CreatePrefList(prefs::kDailyHttpReceivedContentLength);
 105   }
 106
 107   base::Time FakeNow() const {
 108     return now_ + now_delta_;
 109   }
 110
 111   void SetFakeTimeDeltaInHours(int hours) {
 112     now_delta_ = base::TimeDelta::FromHours(hours);
 113   }
 114
 115   void AddFakeTimeDeltaInHours(int hours) {
 116     now_delta_ += base::TimeDelta::FromHours(hours);
 117   }
 118
 119   // Create daily pref list of |kNumDaysInHistory| zero values.
 120   void CreatePrefList(const char* pref) {
 121     ListPrefUpdate update(&pref_service_, pref);
 122     update->Clear();
 123     for (size_t i = 0; i < kNumDaysInHistory; ++i) {
 124       update->Insert(0, new StringValue(base::Int64ToString(0)));
 125     }
 126   }
 127
 128   // Verify the pref list values are equal to the given values.
 129   // If the count of values is less than kNumDaysInHistory, zeros are assumed
 130   // at the beginning.
 131   void VerifyPrefList(const char* pref, const int64* values, size_t count) {
 132     ASSERT_GE(kNumDaysInHistory, count);
 133     ListPrefUpdate update(&pref_service_, pref);
 134     ASSERT_EQ(kNumDaysInHistory, update->GetSize()) << "Pref: " << pref;
 135
 136     for (size_t i = 0; i < count; ++i) {
 137       EXPECT_EQ(
 138           values[i],
 139           GetListPrefInt64Value(*update, kNumDaysInHistory - count + i))
 140           << "index=" << (kNumDaysInHistory - count + i);
 141     }
 142     for (size_t i = 0; i < kNumDaysInHistory - count; ++i) {
 143       EXPECT_EQ(0, GetListPrefInt64Value(*update, i)) << "index=" << i;
 144     }
 145   }
 146
 147   // Verify all daily pref list values.
 148   void VerifyDailyContentLengthPrefLists(
 149       const int64* original_values, size_t original_count,
 150       const int64* received_values, size_t received_count,
 151       const int64* original_with_data_reduction_proxy_enabled_values,
 152       size_t original_with_data_reduction_proxy_enabled_count,
 153       const int64* received_with_data_reduction_proxy_enabled_values,
 154       size_t received_with_data_reduction_proxy_count,
 155       const int64* original_via_data_reduction_proxy_values,
 156       size_t original_via_data_reduction_proxy_count,
 157       const int64* received_via_data_reduction_proxy_values,
 158       size_t received_via_data_reduction_proxy_count) {
 159     VerifyPrefList(prefs::kDailyHttpOriginalContentLength,
 160                    original_values, original_count);
 161     VerifyPrefList(prefs::kDailyHttpReceivedContentLength,
 162                    received_values, received_count);
 163     VerifyPrefList(
 164         prefs::kDailyOriginalContentLengthWithDataReductionProxyEnabled,
 165         original_with_data_reduction_proxy_enabled_values,
 166         original_with_data_reduction_proxy_enabled_count);
 167     VerifyPrefList(
 168         prefs::kDailyContentLengthWithDataReductionProxyEnabled,
 169         received_with_data_reduction_proxy_enabled_values,
 170         received_with_data_reduction_proxy_count);
 171     VerifyPrefList(
 172         prefs::kDailyOriginalContentLengthViaDataReductionProxy,
 173         original_via_data_reduction_proxy_values,
 174         original_via_data_reduction_proxy_count);
 175     VerifyPrefList(
 176         prefs::kDailyContentLengthViaDataReductionProxy,
 177         received_via_data_reduction_proxy_values,
 178         received_via_data_reduction_proxy_count);
 179   }
 180
 181  private:
 182   base::Time now_;
 183   base::TimeDelta now_delta_;
 184 };
 185
 186 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, OneResponse) {
 187   const int64 kOriginalLength = 200;
 188   const int64 kReceivedLength = 100;
 189   int64 original[] = {kOriginalLength};
 190   int64 received[] = {kReceivedLength};
 191
 192   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 193       kReceivedLength, kOriginalLength,
 194       true, true, FakeNow(), &pref_service_);
 195   VerifyDailyContentLengthPrefLists(
 196       original, 1, received, 1,
 197       original, 1, received, 1,
 198       original, 1, received, 1);
 199 }
 200
 201 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, MultipleResponses) {
 202   const int64 kOriginalLength = 150;
 203   const int64 kReceivedLength = 100;
 204   int64 original[] = {kOriginalLength};
 205   int64 received[] = {kReceivedLength};
 206   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 207       kReceivedLength, kOriginalLength,
 208       false, false, FakeNow(), &pref_service_);
 209   VerifyDailyContentLengthPrefLists(
 210       original, 1, received, 1,
 211       NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 212
 213   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 214       kReceivedLength, kOriginalLength,
 215       true, false, FakeNow(), &pref_service_);
 216   original[0] += kOriginalLength;
 217   received[0] += kReceivedLength;
 218   int64 original_proxy_enabled[] = {kOriginalLength};
 219   int64 received_proxy_enabled[] = {kReceivedLength};
 220   VerifyDailyContentLengthPrefLists(
 221       original, 1, received, 1,
 222       original_proxy_enabled, 1, received_proxy_enabled, 1,
 223       NULL, 0, NULL, 0);
 224
 225   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 226       kReceivedLength, kOriginalLength,
 227       true, true, FakeNow(), &pref_service_);
 228   original[0] += kOriginalLength;
 229   received[0] += kReceivedLength;
 230   original_proxy_enabled[0] += kOriginalLength;
 231   received_proxy_enabled[0] += kReceivedLength;
 232   int64 original_via_proxy[] = {kOriginalLength};
 233   int64 received_via_proxy[] = {kReceivedLength};
 234   VerifyDailyContentLengthPrefLists(
 235       original, 1, received, 1,
 236       original_proxy_enabled, 1, received_proxy_enabled, 1,
 237       original_via_proxy, 1, received_via_proxy, 1);
 238
 239   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 240       kReceivedLength, kOriginalLength,
 241       true, false, FakeNow(), &pref_service_);
 242   original[0] += kOriginalLength;
 243   received[0] += kReceivedLength;
 244   original_proxy_enabled[0] += kOriginalLength;
 245   received_proxy_enabled[0] += kReceivedLength;
 246   VerifyDailyContentLengthPrefLists(
 247       original, 1, received, 1,
 248       original_proxy_enabled, 1, received_proxy_enabled, 1,
 249       original_via_proxy, 1, received_via_proxy, 1);
 250
 251   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 252       kReceivedLength, kOriginalLength,
 253       false, false, FakeNow(), &pref_service_);
 254   original[0] += kOriginalLength;
 255   received[0] += kReceivedLength;
 256   VerifyDailyContentLengthPrefLists(
 257       original, 1, received, 1,
 258       original_proxy_enabled, 1, received_proxy_enabled, 1,
 259       original_via_proxy, 1, received_via_proxy, 1);
 260 }
 261
 262 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, ForwardOneDay) {
 263   const int64 kOriginalLength = 200;
 264   const int64 kReceivedLength = 100;
 265
 266   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 267       kReceivedLength, kOriginalLength,
 268       true, true, FakeNow(), &pref_service_);
 269
 270   // Forward one day.
 271   SetFakeTimeDeltaInHours(24);
 272
 273   // Proxy not enabled. Not via proxy.
 274   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 275       kReceivedLength, kOriginalLength,
 276       false, false, FakeNow(), &pref_service_);
 277
 278   int64 original[] = {kOriginalLength, kOriginalLength};
 279   int64 received[] = {kReceivedLength, kReceivedLength};
 280   int64 original_with_data_reduction_proxy_enabled[] = {kOriginalLength, 0};
 281   int64 received_with_data_reduction_proxy_enabled[] = {kReceivedLength, 0};
 282   int64 original_via_data_reduction_proxy[] = {kOriginalLength, 0};
 283   int64 received_via_data_reduction_proxy[] = {kReceivedLength, 0};
 284   VerifyDailyContentLengthPrefLists(
 285       original, 2,
 286       received, 2,
 287       original_with_data_reduction_proxy_enabled, 2,
 288       received_with_data_reduction_proxy_enabled, 2,
 289       original_via_data_reduction_proxy, 2,
 290       received_via_data_reduction_proxy, 2);
 291
 292   // Proxy enabled. Not via proxy.
 293   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 294       kReceivedLength, kOriginalLength,
 295       true, false, FakeNow(), &pref_service_);
 296   original[1] += kOriginalLength;
 297   received[1] += kReceivedLength;
 298   original_with_data_reduction_proxy_enabled[1] += kOriginalLength;
 299   received_with_data_reduction_proxy_enabled[1] += kReceivedLength;
 300   VerifyDailyContentLengthPrefLists(
 301       original, 2,
 302       received, 2,
 303       original_with_data_reduction_proxy_enabled, 2,
 304       received_with_data_reduction_proxy_enabled, 2,
 305       original_via_data_reduction_proxy, 2,
 306       received_via_data_reduction_proxy, 2);
 307
 308   // Proxy enabled and via proxy.
 309   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 310       kReceivedLength, kOriginalLength,
 311       true, true, FakeNow(), &pref_service_);
 312   original[1] += kOriginalLength;
 313   received[1] += kReceivedLength;
 314   original_with_data_reduction_proxy_enabled[1] += kOriginalLength;
 315   received_with_data_reduction_proxy_enabled[1] += kReceivedLength;
 316   original_via_data_reduction_proxy[1] += kOriginalLength;
 317   received_via_data_reduction_proxy[1] += kReceivedLength;
 318   VerifyDailyContentLengthPrefLists(
 319       original, 2,
 320       received, 2,
 321       original_with_data_reduction_proxy_enabled, 2,
 322       received_with_data_reduction_proxy_enabled, 2,
 323       original_via_data_reduction_proxy, 2,
 324       received_via_data_reduction_proxy, 2);
 325 }
 326
 327 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, PartialDayTimeChange) {
 328   const int64 kOriginalLength = 200;
 329   const int64 kReceivedLength = 100;
 330   int64 original[] = {0, kOriginalLength};
 331   int64 received[] = {0, kReceivedLength};
 332
 333   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 334       kReceivedLength, kOriginalLength,
 335       true, true, FakeNow(), &pref_service_);
 336   VerifyDailyContentLengthPrefLists(
 337       original, 2, received, 2,
 338       original, 2, received, 2,
 339       original, 2, received, 2);
 340
 341   // Forward 10 hours, stay in the same day.
 342   // See kLastUpdateTime: "Now" in test is 03:45am.
 343   SetFakeTimeDeltaInHours(10);
 344   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 345       kReceivedLength, kOriginalLength,
 346       true, true, FakeNow(), &pref_service_);
 347   original[1] += kOriginalLength;
 348   received[1] += kReceivedLength;
 349   VerifyDailyContentLengthPrefLists(
 350       original, 2, received, 2,
 351       original, 2, received, 2,
 352       original, 2, received, 2);
 353
 354   // Forward 11 more hours, comes to tomorrow.
 355   AddFakeTimeDeltaInHours(11);
 356   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 357       kReceivedLength, kOriginalLength,
 358       true, true, FakeNow(), &pref_service_);
 359   int64 original2[] = {kOriginalLength * 2, kOriginalLength};
 360   int64 received2[] = {kReceivedLength * 2, kReceivedLength};
 361   VerifyDailyContentLengthPrefLists(
 362       original2, 2, received2, 2,
 363       original2, 2, received2, 2,
 364       original2, 2, received2, 2);
 365 }
 366
 367 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, ForwardMultipleDays) {
 368   const int64 kOriginalLength = 200;
 369   const int64 kReceivedLength = 100;
 370   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 371       kReceivedLength, kOriginalLength,
 372       true, true, FakeNow(), &pref_service_);
 373
 374   // Forward three days.
 375   SetFakeTimeDeltaInHours(3 * 24);
 376
 377   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 378       kReceivedLength, kOriginalLength,
 379       true, true, FakeNow(), &pref_service_);
 380
 381   int64 original[] = {kOriginalLength, 0, 0, kOriginalLength};
 382   int64 received[] = {kReceivedLength, 0, 0, kReceivedLength};
 383   VerifyDailyContentLengthPrefLists(
 384       original, 4, received, 4,
 385       original, 4, received, 4,
 386       original, 4, received, 4);
 387
 388   // Forward four more days.
 389   AddFakeTimeDeltaInHours(4 * 24);
 390   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 391       kReceivedLength, kOriginalLength,
 392       true, true, FakeNow(), &pref_service_);
 393   int64 original2[] = {
 394     kOriginalLength, 0, 0, kOriginalLength, 0, 0, 0, kOriginalLength,
 395   };
 396   int64 received2[] = {
 397     kReceivedLength, 0, 0, kReceivedLength, 0, 0, 0, kReceivedLength,
 398   };
 399   VerifyDailyContentLengthPrefLists(
 400       original2, 8, received2, 8,
 401       original2, 8, received2, 8,
 402       original2, 8, received2, 8);
 403
 404   // Forward |kNumDaysInHistory| more days.
 405   AddFakeTimeDeltaInHours(kNumDaysInHistory * 24);
 406   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 407       kReceivedLength, kOriginalLength,
 408       true, true, FakeNow(), &pref_service_);
 409   int64 original3[] = {kOriginalLength};
 410   int64 received3[] = {kReceivedLength};
 411   VerifyDailyContentLengthPrefLists(
 412       original3, 1, received3, 1,
 413       original3, 1, received3, 1,
 414       original3, 1, received3, 1);
 415
 416   // Forward |kNumDaysInHistory| + 1 more days.
 417   AddFakeTimeDeltaInHours((kNumDaysInHistory + 1)* 24);
 418   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 419       kReceivedLength, kOriginalLength,
 420       true, true, FakeNow(), &pref_service_);
 421   VerifyDailyContentLengthPrefLists(
 422       original3, 1, received3, 1,
 423       original3, 1, received3, 1,
 424       original3, 1, received3, 1);
 425 }
 426
 427 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, BackwardAndForwardOneDay) {
 428   const int64 kOriginalLength = 200;
 429   const int64 kReceivedLength = 100;
 430   int64 original[] = {kOriginalLength};
 431   int64 received[] = {kReceivedLength};
 432
 433   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 434       kReceivedLength, kOriginalLength,
 435       true, true, FakeNow(), &pref_service_);
 436
 437   // Backward one day.
 438   SetFakeTimeDeltaInHours(-24);
 439   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 440       kReceivedLength, kOriginalLength,
 441       true, true, FakeNow(), &pref_service_);
 442   original[0] += kOriginalLength;
 443   received[0] += kReceivedLength;
 444   VerifyDailyContentLengthPrefLists(
 445       original, 1, received, 1,
 446       original, 1, received, 1,
 447       original, 1, received, 1);
 448
 449   // Then, Forward one day
 450   AddFakeTimeDeltaInHours(24);
 451   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 452       kReceivedLength, kOriginalLength,
 453       true, true, FakeNow(), &pref_service_);
 454   int64 original2[] = {kOriginalLength * 2, kOriginalLength};
 455   int64 received2[] = {kReceivedLength * 2, kReceivedLength};
 456   VerifyDailyContentLengthPrefLists(
 457       original2, 2, received2, 2,
 458       original2, 2, received2, 2,
 459       original2, 2, received2, 2);
 460 }
 461
 462 TEST_F(ChromeNetworkDailyDataSavingMetricsTest, BackwardTwoDays) {
 463   const int64 kOriginalLength = 200;
 464   const int64 kReceivedLength = 100;
 465   int64 original[] = {kOriginalLength};
 466   int64 received[] = {kReceivedLength};
 467
 468   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 469       kReceivedLength, kOriginalLength,
 470       true, true, FakeNow(), &pref_service_);
 471   // Backward two days.
 472   SetFakeTimeDeltaInHours(-2 * 24);
 473   chrome_browser_net::UpdateContentLengthPrefsForDataReductionProxy(
 474       kReceivedLength, kOriginalLength,
 475       true, true, FakeNow(), &pref_service_);
 476   VerifyDailyContentLengthPrefLists(
 477       original, 1, received, 1,
 478       original, 1, received, 1,
 479       original, 1, received, 1);
 480 }
 481 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 482
 483 }  // namespace