Create component to expose network usage stats to consumers.

chrome/browser/net/chrome_network_delegate_unittest.cc

 // Copyright (c) 2012 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/chrome_network_delegate.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_member.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
 #include "chrome/browser/net/safe_search_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/content_settings/core/common/pref_names.h"
+#include "components/data_usage/core/data_use_aggregator.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/request_priority.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 49 matching lines @@
   } else {
     request->SetUserData(
         data_use_measurement::DataUseUserData::kUserDataKey,
         new data_use_measurement::DataUseUserData(
             data_use_measurement::DataUseUserData::SUGGESTIONS));
   }
   request->Start();
   base::RunLoop().RunUntilIdle();
 }
 
+// A fake DataUseAggregator for testing that only counts how many times its
+// respective methods have been called.
+class FakeDataUseAggregator : public data_usage::DataUseAggregator {
+ public:
+  FakeDataUseAggregator()
+      : num_report_data_use_calls_(0),
+        num_report_off_the_record_data_use_calls_(0) {}
+
+  ~FakeDataUseAggregator() override {}
+
+  void ReportDataUse(const net::URLRequest& request,
+                     int tab_id,
+                     int64_t tx_bytes,
+                     int64_t rx_bytes) override {
+    ++num_report_data_use_calls_;

[bengr, 2015/10/06 19:30:28]

Is this sufficient for testing? You could add the values to a vector and test
the vector size, among other things.

[sclittle, 2015/10/07 01:07:55]

Changed to keep track of the bytes. The main thing I'm trying to test here is
that on_the_record vs. off_the_record is respected.

+  }
+
+  void ReportOffTheRecordDataUse(int64_t tx_bytes, int64_t rx_bytes) override {
+    ++num_report_off_the_record_data_use_calls_;

[bengr, 2015/10/06 19:30:28]

Here too.

[sclittle, 2015/10/07 01:07:55]

Changed this to keep track of the bytes too.

+  }
+
+  int num_report_data_use_calls() const { return num_report_data_use_calls_; }
+
+  int num_report_off_the_record_data_use_calls() const {
+    return num_report_off_the_record_data_use_calls_;
+  }
+
+ private:
+  int num_report_data_use_calls_;
+  int num_report_off_the_record_data_use_calls_;
+};
+
 }  // namespace
 
 class ChromeNetworkDelegateTest : public testing::Test {
  public:
   ChromeNetworkDelegateTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         context_(new net::TestURLRequestContext(true)) {
 #if defined(ENABLE_EXTENSIONS)
     forwarder_ = new extensions::EventRouterForwarder();
 #endif
@@ skipping 13 matching lines @@
         new ChromeNetworkDelegate(forwarder(), &enable_referrers_));
     context_->set_client_socket_factory(&socket_factory_);
     context_->set_network_delegate(network_delegate_.get());
     context_->Init();
   }
 
   net::TestURLRequestContext* context() { return context_.get(); }
   net::NetworkDelegate* network_delegate() { return network_delegate_.get(); }
   net::MockClientSocketFactory* socket_factory() { return &socket_factory_; }
 
+  ChromeNetworkDelegate* chrome_network_delegate() {
+    return network_delegate_.get();
+  }
+
   extensions::EventRouterForwarder* forwarder() {
 #if defined(ENABLE_EXTENSIONS)
     return forwarder_.get();
 #else
     return nullptr;
 #endif
   }
 
  private:
   scoped_ptr<TestingProfileManager> profile_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
 #if defined(ENABLE_EXTENSIONS)
   scoped_refptr<extensions::EventRouterForwarder> forwarder_;
 #endif
   TestingProfile profile_;
   BooleanPrefMember enable_referrers_;
-  scoped_ptr<net::NetworkDelegate> network_delegate_;
+  scoped_ptr<ChromeNetworkDelegate> network_delegate_;
   net::MockClientSocketFactory socket_factory_;
   scoped_ptr<net::TestURLRequestContext> context_;
 };
 
 // This function tests data use measurement for requests by services. it makes a
 // query which is similar to a query of a service, so it should affect
 // DataUse.TrafficSize.System.Dimensions and DataUse.MessageSize.ServiceName
 // histograms. AppState and ConnectionType dimensions are always Foreground and
 // NotCellular respectively.
 #if !defined(OS_IOS)
@@ skipping 88 matching lines @@
   EXPECT_FALSE(network_delegate()->FirstPartyOnlyCookieExperimentEnabled());
 }
 
 TEST_F(ChromeNetworkDelegateTest, EnableFirstPartyOnlyCookiesIffFlagEnabled) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableExperimentalWebPlatformFeatures);
   Initialize();
   EXPECT_TRUE(network_delegate()->FirstPartyOnlyCookieExperimentEnabled());
 }
 
+TEST_F(ChromeNetworkDelegateTest, ReportDataUseToAggregator) {
+  FakeDataUseAggregator fake_aggregator;
+  Initialize();
+
+  chrome_network_delegate()->set_data_use_aggregator(
+      &fake_aggregator, false /* is_data_usage_off_the_record */);
+  RequestURL(context(), socket_factory(), true, false);
+  EXPECT_GT(fake_aggregator.num_report_data_use_calls(), 0);
+  EXPECT_EQ(0, fake_aggregator.num_report_off_the_record_data_use_calls());
+}
+
+TEST_F(ChromeNetworkDelegateTest, ReportOffTheRecordDataUseToAggregator) {
+  FakeDataUseAggregator fake_aggregator;
+  Initialize();
+
+  chrome_network_delegate()->set_data_use_aggregator(
+      &fake_aggregator, true /* is_data_usage_off_the_record */);
+  RequestURL(context(), socket_factory(), true, false);
+  EXPECT_EQ(0, fake_aggregator.num_report_data_use_calls());
+  EXPECT_GT(fake_aggregator.num_report_off_the_record_data_use_calls(), 0);
+}
+
 class ChromeNetworkDelegateSafeSearchTest : public testing::Test {
  public:
   ChromeNetworkDelegateSafeSearchTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 #if defined(ENABLE_EXTENSIONS)
     forwarder_ = new extensions::EventRouterForwarder();
 #endif
   }
 
   void SetUp() override {
@@ skipping 191 matching lines @@
                                                        kBlockedFirstPartySite));
 
   cookie_settings_->SetCookieSetting(
       ContentSettingsPattern::FromURL(kBlockedFirstPartySite),
       ContentSettingsPattern::Wildcard(),
       CONTENT_SETTING_BLOCK);
   // Privacy mode is disabled as kAllowedSite is still getting cookies
   EXPECT_FALSE(network_delegate_->CanEnablePrivacyMode(kAllowedSite,
                                                        kBlockedFirstPartySite));
 }