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 <stdint.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"
 #include "url/gurl.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #endif
 
 #if !defined(OS_IOS)
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #endif
 
 namespace {
 
 // This function requests a URL, and makes it return a known response. If
 // |from_user| is true, it attaches a ResourceRequestInfo to the URLRequest,
 // because requests from users have this info. If |from_user| is false, the
 // request is presumed to be from a service, and the service name is set in the
 // request's user data. (As an example suggestions service tag is attached). if
 // |redirect| is true, it adds necessary socket data to have it follow redirect
 // before getting the final response.
-void RequestURL(net::URLRequestContext* context,
-                net::MockClientSocketFactory* socket_factory,
-                bool from_user,
-                bool redirect) {
+scoped_ptr<net::URLRequest> RequestURL(
+    net::URLRequestContext* context,
+    net::MockClientSocketFactory* socket_factory,
+    bool from_user,
+    bool redirect) {
   net::MockRead redirect_mock_reads[] = {
       net::MockRead("HTTP/1.1 302 Found\r\n"
                     "Location: http://bar.com/\r\n\r\n"),
       net::MockRead(net::SYNCHRONOUS, net::OK),
   };
   net::StaticSocketDataProvider redirect_socket_data_provider(
       redirect_mock_reads, arraysize(redirect_mock_reads), nullptr, 0);
 
   if (redirect)
     socket_factory->AddSocketDataProvider(&redirect_socket_data_provider);
@@ skipping 14 matching lines @@
         request.get(), content::RESOURCE_TYPE_MAIN_FRAME, nullptr, -2, -2, -2,
         true, false, true, true);
   } else {
     request->SetUserData(
         data_use_measurement::DataUseUserData::kUserDataKey,
         new data_use_measurement::DataUseUserData(
             data_use_measurement::DataUseUserData::SUGGESTIONS));
   }
   request->Start();
   base::RunLoop().RunUntilIdle();
+  return request.Pass();
 }
 
+// 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()
+      : on_the_record_tx_bytes_(0),
+        on_the_record_rx_bytes_(0),
+        off_the_record_tx_bytes_(0),
+        off_the_record_rx_bytes_(0) {}
+  ~FakeDataUseAggregator() override {}
+
+  void ReportDataUse(const net::URLRequest& request,
+                     int32_t tab_id,
+                     int64_t tx_bytes,
+                     int64_t rx_bytes) override {
+    on_the_record_tx_bytes_ += tx_bytes;
+    on_the_record_rx_bytes_ += rx_bytes;
+  }
+
+  void ReportOffTheRecordDataUse(int64_t tx_bytes, int64_t rx_bytes) override {
+    off_the_record_tx_bytes_ += tx_bytes;
+    off_the_record_rx_bytes_ += rx_bytes;
+  }
+
+  int64_t on_the_record_tx_bytes() const { return on_the_record_tx_bytes_; }
+  int64_t on_the_record_rx_bytes() const { return on_the_record_rx_bytes_; }
+  int64_t off_the_record_tx_bytes() const { return off_the_record_tx_bytes_; }
+  int64_t off_the_record_rx_bytes() const { return off_the_record_rx_bytes_; }
+
+ private:
+  int64_t on_the_record_tx_bytes_;
+  int64_t on_the_record_rx_bytes_;
+  int64_t off_the_record_tx_bytes_;
+  int64_t off_the_record_rx_bytes_;
+};
+
 }  // 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 */);
+
+  scoped_ptr<net::URLRequest> request =
+      RequestURL(context(), socket_factory(), true, false);
+  EXPECT_EQ(request->GetTotalSentBytes(),
+            fake_aggregator.on_the_record_tx_bytes());
+  EXPECT_EQ(request->GetTotalReceivedBytes(),
+            fake_aggregator.on_the_record_rx_bytes());
+  EXPECT_EQ(0, fake_aggregator.off_the_record_tx_bytes());
+  EXPECT_EQ(0, fake_aggregator.off_the_record_rx_bytes());
+}
+
+TEST_F(ChromeNetworkDelegateTest, ReportOffTheRecordDataUseToAggregator) {
+  FakeDataUseAggregator fake_aggregator;
+  Initialize();
+
+  chrome_network_delegate()->set_data_use_aggregator(
+      &fake_aggregator, true /* is_data_usage_off_the_record */);
+  scoped_ptr<net::URLRequest> request =
+      RequestURL(context(), socket_factory(), true, false);
+
+  EXPECT_EQ(0, fake_aggregator.on_the_record_tx_bytes());
+  EXPECT_EQ(0, fake_aggregator.on_the_record_rx_bytes());
+  EXPECT_EQ(request->GetTotalSentBytes(),
+            fake_aggregator.off_the_record_tx_bytes());
+  EXPECT_EQ(request->GetTotalReceivedBytes(),
+            fake_aggregator.off_the_record_rx_bytes());
+}
+
 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));
 }