| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 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 "components/data_use_measurement/content/data_use_measurement.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/macros.h" | |
| 11 #include "base/message_loop/message_loop.h" | |
| 12 #include "base/run_loop.h" | |
| 13 #include "base/test/histogram_tester.h" | |
| 14 #include "build/build_config.h" | |
| 15 #include "content/public/browser/resource_request_info.h" | |
| 16 #include "net/base/network_change_notifier.h" | |
| 17 #include "net/base/request_priority.h" | |
| 18 #include "net/socket/socket_test_util.h" | |
| 19 #include "net/url_request/url_request.h" | |
| 20 #include "net/url_request/url_request_test_util.h" | |
| 21 #include "testing/gtest/include/gtest/gtest.h" | |
| 22 #include "url/gurl.h" | |
| 23 | |
| 24 #if defined(OS_ANDROID) | |
| 25 #include "base/android/application_status_listener.h" | |
| 26 #endif | |
| 27 | |
| 28 namespace data_use_measurement { | |
| 29 | |
| 30 class DataUseMeasurementTest : public testing::Test { | |
| 31 public: | |
| 32 DataUseMeasurementTest() | |
| 33 : data_use_measurement_( | |
| 34 base::Bind(&DataUseMeasurementTest::FakeDataUseforwarder, | |
| 35 base::Unretained(this))) { | |
| 36 // During the test it is expected to not have cellular connection. | |
| 37 DCHECK(!net::NetworkChangeNotifier::IsConnectionCellular( | |
| 38 net::NetworkChangeNotifier::GetConnectionType())); | |
| 39 } | |
| 40 | |
| 41 // Creates a test request. | |
| 42 std::unique_ptr<net::URLRequest> CreateTestRequest(bool is_user_request) { | |
| 43 net::TestDelegate test_delegate; | |
| 44 InitializeContext(); | |
| 45 net::MockRead reads[] = {net::MockRead("HTTP/1.1 200 OK\r\n" | |
| 46 "Content-Length: 12\r\n\r\n"), | |
| 47 net::MockRead("Test Content")}; | |
| 48 net::StaticSocketDataProvider socket_data(reads, arraysize(reads), nullptr, | |
| 49 0); | |
| 50 socket_factory_->AddSocketDataProvider(&socket_data); | |
| 51 | |
| 52 std::unique_ptr<net::URLRequest> request(context_->CreateRequest( | |
| 53 GURL("http://foo.com"), net::DEFAULT_PRIORITY, &test_delegate)); | |
| 54 if (is_user_request) { | |
| 55 request->SetUserData( | |
| 56 data_use_measurement::DataUseUserData::kUserDataKey, | |
| 57 new data_use_measurement::DataUseUserData( | |
| 58 data_use_measurement::DataUseUserData::SUGGESTIONS, | |
| 59 data_use_measurement_.CurrentAppState())); | |
| 60 } else { | |
| 61 content::ResourceRequestInfo::AllocateForTesting( | |
| 62 request.get(), content::RESOURCE_TYPE_MAIN_FRAME, nullptr, -2, -2, -2, | |
| 63 true, false, true, true, false); | |
| 64 } | |
| 65 | |
| 66 request->Start(); | |
| 67 base::RunLoop().RunUntilIdle(); | |
| 68 return request; | |
| 69 } | |
| 70 | |
| 71 // Sends a request and reports data use attaching either user data or service | |
| 72 // data based on |is_user_request|. | |
| 73 void SendRequest(bool is_user_request) { | |
| 74 std::unique_ptr<net::URLRequest> request = | |
| 75 CreateTestRequest(is_user_request); | |
| 76 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 77 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 78 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 79 data_use_measurement_.OnCompleted(*request, true); | |
| 80 } | |
| 81 | |
| 82 // This function makes a user request and confirms that its effect is | |
| 83 // reflected in proper histograms. | |
| 84 void TestForAUserRequest(const std::string& target_dimension) { | |
| 85 base::HistogramTester histogram_tester; | |
| 86 SendRequest(true); | |
| 87 histogram_tester.ExpectTotalCount("DataUse.TrafficSize.System.Downstream." + | |
| 88 target_dimension + kConnectionType, | |
| 89 1); | |
| 90 histogram_tester.ExpectTotalCount("DataUse.TrafficSize.System.Upstream." + | |
| 91 target_dimension + kConnectionType, | |
| 92 1); | |
| 93 // One upload and one download message, so total count should be 2. | |
| 94 histogram_tester.ExpectTotalCount("DataUse.MessageSize.Suggestions", 2); | |
| 95 } | |
| 96 | |
| 97 // This function makes a service request and confirms that its effect is | |
| 98 // reflected in proper histograms. | |
| 99 void TestForAServiceRequest(const std::string& target_dimension) { | |
| 100 base::HistogramTester histogram_tester; | |
| 101 SendRequest(false); | |
| 102 histogram_tester.ExpectTotalCount("DataUse.TrafficSize.User.Downstream." + | |
| 103 target_dimension + kConnectionType, | |
| 104 1); | |
| 105 histogram_tester.ExpectTotalCount("DataUse.TrafficSize.User.Upstream." + | |
| 106 target_dimension + kConnectionType, | |
| 107 1); | |
| 108 histogram_tester.ExpectTotalCount( | |
| 109 "DataUse.MessageSize.AllServices.Upstream." + target_dimension + | |
| 110 kConnectionType, | |
| 111 0); | |
| 112 histogram_tester.ExpectTotalCount( | |
| 113 "DataUse.MessageSize.AllServices.Downstream." + target_dimension + | |
| 114 kConnectionType, | |
| 115 0); | |
| 116 } | |
| 117 | |
| 118 DataUseMeasurement* data_use_measurement() { return &data_use_measurement_; } | |
| 119 | |
| 120 bool IsDataUseForwarderCalled() { return is_data_use_forwarder_called_; } | |
| 121 | |
| 122 protected: | |
| 123 void InitializeContext() { | |
| 124 context_.reset(new net::TestURLRequestContext(true)); | |
| 125 socket_factory_.reset(new net::MockClientSocketFactory()); | |
| 126 context_->set_client_socket_factory(socket_factory_.get()); | |
| 127 context_->Init(); | |
| 128 } | |
| 129 | |
| 130 void FakeDataUseforwarder(const std::string& service_name, | |
| 131 int message_size, | |
| 132 bool is_celllular) { | |
| 133 is_data_use_forwarder_called_ = true; | |
| 134 } | |
| 135 | |
| 136 base::MessageLoopForIO loop_; | |
| 137 DataUseMeasurement data_use_measurement_; | |
| 138 std::unique_ptr<net::MockClientSocketFactory> socket_factory_; | |
| 139 std::unique_ptr<net::TestURLRequestContext> context_; | |
| 140 const std::string kConnectionType = "NotCellular"; | |
| 141 bool is_data_use_forwarder_called_ = false; | |
| 142 | |
| 143 DISALLOW_COPY_AND_ASSIGN(DataUseMeasurementTest); | |
| 144 }; | |
| 145 | |
| 146 // This test function tests recording of data use information in UMA histogram | |
| 147 // when packet is originated from user or services when the app is in the | |
| 148 // foreground or the OS is not Android. | |
| 149 // TODO(amohammadkhan): Add tests for Cellular/non-cellular connection types | |
| 150 // when support for testing is provided in its class. | |
| 151 TEST_F(DataUseMeasurementTest, UserNotUserTest) { | |
| 152 #if defined(OS_ANDROID) | |
| 153 data_use_measurement()->OnApplicationStateChangeForTesting( | |
| 154 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); | |
| 155 #endif | |
| 156 TestForAServiceRequest("Foreground."); | |
| 157 TestForAUserRequest("Foreground."); | |
| 158 } | |
| 159 | |
| 160 #if defined(OS_ANDROID) | |
| 161 // This test function tests recording of data use information in UMA histogram | |
| 162 // when packet is originated from user or services when the app is in the | |
| 163 // background and OS is Android. | |
| 164 TEST_F(DataUseMeasurementTest, ApplicationStateTest) { | |
| 165 data_use_measurement()->OnApplicationStateChangeForTesting( | |
| 166 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES); | |
| 167 TestForAServiceRequest("Background."); | |
| 168 TestForAUserRequest("Background."); | |
| 169 } | |
| 170 #endif | |
| 171 | |
| 172 TEST_F(DataUseMeasurementTest, DataUseForwarderIsCalled) { | |
| 173 EXPECT_FALSE(IsDataUseForwarderCalled()); | |
| 174 SendRequest(true); | |
| 175 EXPECT_TRUE(IsDataUseForwarderCalled()); | |
| 176 } | |
| 177 | |
| 178 #if defined(OS_ANDROID) | |
| 179 TEST_F(DataUseMeasurementTest, AppStateUnknown) { | |
| 180 base::HistogramTester histogram_tester; | |
| 181 std::unique_ptr<net::URLRequest> request = CreateTestRequest(false); | |
| 182 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 183 | |
| 184 { | |
| 185 base::HistogramTester histogram_tester; | |
| 186 data_use_measurement()->OnApplicationStateChangeForTesting( | |
| 187 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); | |
| 188 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 189 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 190 histogram_tester.ExpectTotalCount( | |
| 191 "DataUse.TrafficSize.User.Downstream.Foreground." + kConnectionType, 1); | |
| 192 histogram_tester.ExpectTotalCount( | |
| 193 "DataUse.TrafficSize.User.Upstream.Foreground." + kConnectionType, 1); | |
| 194 } | |
| 195 | |
| 196 { | |
| 197 base::HistogramTester histogram_tester; | |
| 198 data_use_measurement()->OnApplicationStateChangeForTesting( | |
| 199 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES); | |
| 200 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 201 histogram_tester.ExpectTotalCount( | |
| 202 "DataUse.TrafficSize.User.Downstream.Unknown." + kConnectionType, 1); | |
| 203 } | |
| 204 | |
| 205 { | |
| 206 base::HistogramTester histogram_tester; | |
| 207 data_use_measurement()->OnApplicationStateChangeForTesting( | |
| 208 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES); | |
| 209 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 210 histogram_tester.ExpectTotalCount( | |
| 211 "DataUse.TrafficSize.User.Downstream.Background." + kConnectionType, 1); | |
| 212 } | |
| 213 } | |
| 214 | |
| 215 TEST_F(DataUseMeasurementTest, TimeOfBackgroundDownstreamBytes) { | |
| 216 { | |
| 217 std::unique_ptr<net::URLRequest> request = CreateTestRequest(false); | |
| 218 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 219 base::HistogramTester histogram_tester; | |
| 220 data_use_measurement()->OnApplicationStateChange( | |
| 221 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); | |
| 222 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 223 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 224 data_use_measurement_.OnNetworkBytesSent(*request, 200); | |
| 225 data_use_measurement_.OnNetworkBytesReceived(*request, 2000); | |
| 226 histogram_tester.ExpectTotalCount( | |
| 227 "DataUse.BackgroundToDataRecievedPerByte.User", 0); | |
| 228 histogram_tester.ExpectTotalCount( | |
| 229 "DataUse.BackgroundToFirstDownstream.User", 0); | |
| 230 } | |
| 231 | |
| 232 { | |
| 233 // Create new request when app is in foreground.. | |
| 234 base::HistogramTester histogram_tester; | |
| 235 std::unique_ptr<net::URLRequest> request = CreateTestRequest(false); | |
| 236 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 237 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 238 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 239 data_use_measurement_.OnNetworkBytesSent(*request, 200); | |
| 240 data_use_measurement_.OnNetworkBytesReceived(*request, 2000); | |
| 241 histogram_tester.ExpectTotalCount( | |
| 242 "DataUse.BackgroundToDataRecievedPerByte.User", 0); | |
| 243 histogram_tester.ExpectTotalCount( | |
| 244 "DataUse.BackgroundToFirstDownstream.User", 0); | |
| 245 } | |
| 246 | |
| 247 { | |
| 248 std::unique_ptr<net::URLRequest> request = CreateTestRequest(false); | |
| 249 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 250 base::HistogramTester histogram_tester; | |
| 251 data_use_measurement()->OnApplicationStateChange( | |
| 252 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES); | |
| 253 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 254 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 255 data_use_measurement_.OnNetworkBytesSent(*request, 200); | |
| 256 data_use_measurement_.OnNetworkBytesReceived(*request, 2000); | |
| 257 histogram_tester.ExpectTotalCount( | |
| 258 "DataUse.BackgroundToDataRecievedPerByte.User", 3000); | |
| 259 histogram_tester.ExpectTotalCount( | |
| 260 "DataUse.BackgroundToFirstDownstream.User", 1); | |
| 261 } | |
| 262 | |
| 263 { | |
| 264 // Create new request when app is in background. | |
| 265 base::HistogramTester histogram_tester; | |
| 266 std::unique_ptr<net::URLRequest> request = CreateTestRequest(false); | |
| 267 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 268 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 269 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 270 data_use_measurement_.OnNetworkBytesSent(*request, 200); | |
| 271 data_use_measurement_.OnNetworkBytesReceived(*request, 2000); | |
| 272 histogram_tester.ExpectTotalCount( | |
| 273 "DataUse.BackgroundToDataRecievedPerByte.User", 3000); | |
| 274 histogram_tester.ExpectTotalCount( | |
| 275 "DataUse.BackgroundToFirstDownstream.User", 0); | |
| 276 } | |
| 277 | |
| 278 { | |
| 279 // Create new request when app is in background. | |
| 280 base::HistogramTester histogram_tester; | |
| 281 std::unique_ptr<net::URLRequest> request = CreateTestRequest(true); | |
| 282 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 283 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 284 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 285 data_use_measurement_.OnNetworkBytesSent(*request, 200); | |
| 286 data_use_measurement_.OnNetworkBytesReceived(*request, 2000); | |
| 287 histogram_tester.ExpectTotalCount( | |
| 288 "DataUse.BackgroundToDataRecievedPerByte.System", 3000); | |
| 289 histogram_tester.ExpectTotalCount( | |
| 290 "DataUse.BackgroundToDataRecievedPerByte.User", 0); | |
| 291 histogram_tester.ExpectTotalCount( | |
| 292 "DataUse.BackgroundToFirstDownstream.System", 0); | |
| 293 histogram_tester.ExpectTotalCount( | |
| 294 "DataUse.BackgroundToFirstDownstream.User", 0); | |
| 295 } | |
| 296 | |
| 297 { | |
| 298 std::unique_ptr<net::URLRequest> request = CreateTestRequest(false); | |
| 299 data_use_measurement_.OnBeforeURLRequest(request.get()); | |
| 300 base::HistogramTester histogram_tester; | |
| 301 data_use_measurement()->OnApplicationStateChange( | |
| 302 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); | |
| 303 data_use_measurement_.OnNetworkBytesSent(*request, 100); | |
| 304 data_use_measurement_.OnNetworkBytesReceived(*request, 1000); | |
| 305 data_use_measurement_.OnNetworkBytesSent(*request, 200); | |
| 306 data_use_measurement_.OnNetworkBytesReceived(*request, 2000); | |
| 307 histogram_tester.ExpectTotalCount( | |
| 308 "DataUse.BackgroundToDataRecievedPerByte.User", 0); | |
| 309 histogram_tester.ExpectTotalCount( | |
| 310 "DataUse.BackgroundToFirstDownstream.User", 0); | |
| 311 } | |
| 312 } | |
| 313 #endif | |
| 314 | |
| 315 } // namespace data_use_measurement | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2462983003:
Move data use measurement to DataUseNetworkDelegate (Closed)
