Support needed to measure user and service traffic in Chrome.

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/test/histogram_tester.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
+#include "chrome/browser/net/data_use_user_data.h"
 #include "chrome/browser/net/safe_search_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/content_settings/core/common/pref_names.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/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #endif
 
@@ skipping 78 matching lines @@
 
     request->Start();
     base::MessageLoop::current()->RunUntilIdle();
 
     EXPECT_EQ(expect_google_safe_search ? 1 : 0,
         safe_search_util::GetForceGoogleSafeSearchCountForTesting());
     EXPECT_EQ(expect_youtube_safety_mode ? 1 : 0,
         safe_search_util::GetForceYouTubeSafetyModeCountForTesting());
   }
 
+  // This function queries a URLRequest. If |from_user| is true, so it attaches
+  // a ResourceRequestInfo to the URLRequest, because requests from users have
+  // this info. If |from_user| is false, the request assumed to be from one of
+  // the services so it attaches a DataUseUserData. ServiceName is used as the
+  // name of the service owning this request.
+  void QueryURLDataUse(bool from_user) {
+    scoped_ptr<net::URLRequest> request(context_.CreateRequest(
+        GURL("http://example.com"), net::DEFAULT_PRIORITY, &delegate_));
+    // The render_process_id should be negative, all the other parameters are
+    // arbitrary.
+    if (from_user) {
+      content::ResourceRequestInfo::AllocateForTesting(
+          request.get(),
+          content::RESOURCE_TYPE_MAIN_FRAME,
+          NULL,
+          -2,  // render_process_id
+          -2,
+          -2,
+          true,
+          false,
+          true,
+          true);
+    } else {
+      request->SetUserData(DataUseUserData::kUserDataKey,
+                           new DataUseUserData("ServiceName"));
+    }
+    request->Start();
+    base::MessageLoop::current()->RunUntilIdle();
+  }
+
  private:
   extensions::EventRouterForwarder* forwarder() {
 #if defined(ENABLE_EXTENSIONS)
     return forwarder_.get();
 #else
     return NULL;
 #endif
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
@@ skipping 17 matching lines @@
   // Loop over all combinations of the two policies.
   for (int i = 0; i < 4; i++) {
     bool google_safe_search = i % 2;
     bool youtube_safety_mode = i / 2;
     SetSafeSearch(google_safe_search, youtube_safety_mode);
 
     QueryURL(google_safe_search, youtube_safety_mode);
   }
 }
 
+// This function tests data use measurement for different types of requests by
+// making two queries. First query is similar to a query from a service, so it
+// should affect DataUse.NotUser.Dimensions and DataUse.service.ServiceName
+// histograms. The second query is similar to a query from a user, so it should
+// affect DataUse.User.Dimensions. AppState and ConnectionType dimensions are
+// always Foreground and NotCellular respectively. Because Background dimension
+// is only defined for android platform and when Chrome is in background and
+// Cellular ConnectionType is only exist on mobile devices.
+TEST_F(ChromeNetworkDelegateSafeSearchTest, DataUseMeasurement) {
+  scoped_ptr<net::NetworkDelegate> delegate(CreateNetworkDelegate());
+  SetDelegate(delegate.get());
+
+  base::HistogramTester histogram_tester;
+
+  QueryURLDataUse(0); // A query from a service
+  histogram_tester.ExpectTotalCount(
+      "DataUse.NotUser.Download.Foreground.NotCellular", 1);
+  histogram_tester.ExpectTotalCount(
+      "DataUse.NotUser.Upload.Foreground.NotCellular", 1);
+  // One upload and one download message, so totalCount shoudl be 2.
+  histogram_tester.ExpectTotalCount("DataUse.Service.ServiceName", 2);
+  // The upload nad download messages are empty, so their size should be 0.
+  histogram_tester.ExpectUniqueSample("DataUse.Service.ServiceName", 0, 2);
+
+  QueryURLDataUse(1); // A query from user
+  histogram_tester.ExpectTotalCount(
+      "DataUse.User.Download.Foreground.NotCellular", 1);
+  histogram_tester.ExpectTotalCount(
+      "DataUse.User.Upload.Foreground.NotCellular", 1);
+}
+
 // Privacy Mode disables Channel Id if cookies are blocked (cr223191)
 class ChromeNetworkDelegatePrivacyModeTest : public testing::Test {
  public:
   ChromeNetworkDelegatePrivacyModeTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
 #if defined(ENABLE_EXTENSIONS)
         forwarder_(new extensions::EventRouterForwarder()),
 #endif
         cookie_settings_(CookieSettingsFactory::GetForProfile(&profile_).get()),
         kBlockedSite("http://ads.thirdparty.com"),
@@ skipping 96 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));
 }