OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/android/data_usage/external_data_use_observer.h" | 5 #include "chrome/browser/android/data_usage/external_data_use_observer.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
11 #include "base/memory/scoped_vector.h" | 11 #include "base/memory/scoped_vector.h" |
| 12 #include "base/metrics/field_trial.h" |
12 #include "base/run_loop.h" | 13 #include "base/run_loop.h" |
13 #include "base/strings/string_number_conversions.h" | 14 #include "base/strings/string_number_conversions.h" |
14 #include "base/thread_task_runner_handle.h" | 15 #include "base/thread_task_runner_handle.h" |
15 #include "components/data_usage/core/data_use.h" | 16 #include "components/data_usage/core/data_use.h" |
16 #include "components/data_usage/core/data_use_aggregator.h" | 17 #include "components/data_usage/core/data_use_aggregator.h" |
| 18 #include "components/variations/variations_associated_data.h" |
17 #include "content/public/browser/browser_thread.h" | 19 #include "content/public/browser/browser_thread.h" |
18 #include "content/public/test/test_browser_thread_bundle.h" | 20 #include "content/public/test/test_browser_thread_bundle.h" |
19 #include "net/base/network_change_notifier.h" | 21 #include "net/base/network_change_notifier.h" |
20 #include "testing/gtest/include/gtest/gtest.h" | 22 #include "testing/gtest/include/gtest/gtest.h" |
21 #include "url/gurl.h" | 23 #include "url/gurl.h" |
22 | 24 |
23 namespace chrome { | 25 namespace chrome { |
24 | 26 |
25 namespace android { | 27 namespace android { |
26 | 28 |
27 class ExternalDataUseObserverTest : public testing::Test { | 29 class ExternalDataUseObserverTest : public testing::Test { |
28 public: | 30 public: |
29 void SetUp() override { | 31 void SetUp() override { |
30 thread_bundle_.reset(new content::TestBrowserThreadBundle( | 32 thread_bundle_.reset(new content::TestBrowserThreadBundle( |
31 content::TestBrowserThreadBundle::REAL_IO_THREAD)); | 33 content::TestBrowserThreadBundle::REAL_IO_THREAD)); |
32 io_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread( | 34 io_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread( |
33 content::BrowserThread::IO); | 35 content::BrowserThread::IO); |
34 ui_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread( | 36 ui_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread( |
35 content::BrowserThread::UI); | 37 content::BrowserThread::UI); |
36 data_use_aggregator_.reset(new data_usage::DataUseAggregator()); | 38 data_use_aggregator_.reset(new data_usage::DataUseAggregator()); |
37 external_data_use_observer_.reset(new ExternalDataUseObserver( | 39 external_data_use_observer_.reset(new ExternalDataUseObserver( |
38 data_use_aggregator_.get(), io_task_runner_.get(), | 40 data_use_aggregator_.get(), io_task_runner_.get(), |
39 ui_task_runner_.get())); | 41 ui_task_runner_.get())); |
40 } | 42 } |
41 | 43 |
| 44 scoped_ptr<ExternalDataUseObserver> Create() const { |
| 45 return scoped_ptr<ExternalDataUseObserver>(new ExternalDataUseObserver( |
| 46 data_use_aggregator_.get(), io_task_runner_.get(), |
| 47 ui_task_runner_.get())); |
| 48 } |
| 49 |
42 ExternalDataUseObserver* external_data_use_observer() const { | 50 ExternalDataUseObserver* external_data_use_observer() const { |
43 return external_data_use_observer_.get(); | 51 return external_data_use_observer_.get(); |
44 } | 52 } |
45 | 53 |
46 private: | 54 private: |
47 // Required for creating multiple threads for unit testing. | 55 // Required for creating multiple threads for unit testing. |
48 scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_; | 56 scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_; |
49 scoped_ptr<data_usage::DataUseAggregator> data_use_aggregator_; | 57 scoped_ptr<data_usage::DataUseAggregator> data_use_aggregator_; |
50 scoped_ptr<ExternalDataUseObserver> external_data_use_observer_; | 58 scoped_ptr<ExternalDataUseObserver> external_data_use_observer_; |
51 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_; | 59 scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_; |
(...skipping 188 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
240 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( | 248 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
241 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, | 249 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
242 std::vector<std::string>(url_regexes.size(), label)); | 250 std::vector<std::string>(url_regexes.size(), label)); |
243 EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size()); | 251 EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size()); |
244 EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_); | 252 EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_); |
245 EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_); | 253 EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_); |
246 | 254 |
247 std::vector<const data_usage::DataUse*> data_use_sequence; | 255 std::vector<const data_usage::DataUse*> data_use_sequence; |
248 data_usage::DataUse data_use_foo( | 256 data_usage::DataUse data_use_foo( |
249 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 257 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
250 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1, 2); | 258 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", |
| 259 external_data_use_observer()->data_use_report_min_bytes_, 1); |
251 data_use_sequence.push_back(&data_use_foo); | 260 data_use_sequence.push_back(&data_use_foo); |
252 data_usage::DataUse data_use_bar( | 261 data_usage::DataUse data_use_bar( |
253 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 262 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
254 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", 1, 2); | 263 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", |
| 264 external_data_use_observer()->data_use_report_min_bytes_, 1); |
255 data_use_sequence.push_back(&data_use_bar); | 265 data_use_sequence.push_back(&data_use_bar); |
256 external_data_use_observer()->OnDataUse(data_use_sequence); | 266 external_data_use_observer()->OnDataUse(data_use_sequence); |
257 | 267 |
258 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); | 268 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); |
259 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); | 269 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); |
260 } | 270 } |
261 | 271 |
262 // Verifies that buffer size does not exceed the specified limit. | 272 // Verifies that buffer size does not exceed the specified limit. |
263 TEST_F(ExternalDataUseObserverTest, BufferSize) { | 273 TEST_F(ExternalDataUseObserverTest, BufferSize) { |
264 const std::string label("label"); | 274 const std::string label("label"); |
265 | 275 |
266 std::vector<std::string> url_regexes; | 276 std::vector<std::string> url_regexes; |
267 url_regexes.push_back( | 277 url_regexes.push_back( |
268 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); | 278 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
269 | 279 |
270 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( | 280 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
271 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, | 281 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
272 std::vector<std::string>(url_regexes.size(), label)); | 282 std::vector<std::string>(url_regexes.size(), label)); |
273 | 283 |
274 const size_t max_buffer_size = ExternalDataUseObserver::kMaxBufferSize; | 284 const size_t max_buffer_size = ExternalDataUseObserver::kMaxBufferSize; |
| 285 const int bytes_downloaded = 1000; |
| 286 const int bytes_uploaded = 100; |
275 | 287 |
276 ScopedVector<data_usage::DataUse> data_use_vector; | 288 ScopedVector<data_usage::DataUse> data_use_vector; |
277 // Push more entries than the buffer size. Buffer size should not be exceeded. | 289 // Push more entries than the buffer size. Buffer size should not be exceeded. |
278 for (size_t i = 0; i < max_buffer_size * 5; ++i) { | 290 for (size_t i = 0; i < max_buffer_size * 5; ++i) { |
279 scoped_ptr<data_usage::DataUse> data_use(new data_usage::DataUse( | 291 scoped_ptr<data_usage::DataUse> data_use(new data_usage::DataUse( |
280 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 292 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
281 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, | 293 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, |
282 "mccmnc" + base::Int64ToString(i), 0, 0)); | 294 "mccmnc" + base::Int64ToString(i), bytes_downloaded, bytes_uploaded)); |
283 data_use_vector.push_back(data_use.Pass()); | 295 data_use_vector.push_back(data_use.Pass()); |
284 } | 296 } |
285 | 297 |
286 std::vector<const data_usage::DataUse*> const_sequence( | 298 std::vector<const data_usage::DataUse*> const_sequence( |
287 data_use_vector.begin(), data_use_vector.end()); | 299 data_use_vector.begin(), data_use_vector.end()); |
288 | 300 |
289 external_data_use_observer()->OnDataUse(const_sequence); | 301 external_data_use_observer()->OnDataUse(const_sequence); |
290 // One report will be consumed. | 302 EXPECT_LE(0, external_data_use_observer()->total_bytes_buffered_); |
| 303 |
| 304 // One report will be consumed. Verify that total buffered bytes is computed |
| 305 // correctly. |
| 306 EXPECT_EQ(static_cast<int64_t>((max_buffer_size - 1) * |
| 307 (bytes_downloaded + bytes_uploaded)), |
| 308 external_data_use_observer()->total_bytes_buffered_); |
291 EXPECT_EQ(max_buffer_size - 1, | 309 EXPECT_EQ(max_buffer_size - 1, |
292 external_data_use_observer()->buffered_data_reports_.size()); | 310 external_data_use_observer()->buffered_data_reports_.size()); |
293 | 311 |
294 // Verify the label of the data use report. | 312 // Verify the label of the data use report. |
295 for (const auto& it : external_data_use_observer()->buffered_data_reports_) | 313 for (const auto& it : external_data_use_observer()->buffered_data_reports_) |
296 EXPECT_EQ(label, it.first.label); | 314 EXPECT_EQ(label, it.first.label); |
297 } | 315 } |
298 | 316 |
299 // Tests that buffered data use reports are merged correctly. | 317 // Tests that buffered data use reports are merged correctly. |
300 TEST_F(ExternalDataUseObserverTest, ReportsMergedCorrectly) { | 318 TEST_F(ExternalDataUseObserverTest, ReportsMergedCorrectly) { |
301 const std::string label("label"); | 319 const std::string label("label"); |
302 | 320 |
303 std::vector<std::string> url_regexes; | 321 std::vector<std::string> url_regexes; |
304 url_regexes.push_back( | 322 url_regexes.push_back( |
305 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); | 323 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
306 | 324 |
307 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( | 325 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
308 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, | 326 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
309 std::vector<std::string>(url_regexes.size(), label)); | 327 std::vector<std::string>(url_regexes.size(), label)); |
310 | 328 |
311 const size_t num_iterations = ExternalDataUseObserver::kMaxBufferSize * 5; | 329 const size_t num_iterations = ExternalDataUseObserver::kMaxBufferSize * 5; |
312 | 330 |
313 ScopedVector<data_usage::DataUse> data_use_vector; | 331 ScopedVector<data_usage::DataUse> data_use_vector; |
314 for (size_t i = 0; i < num_iterations; ++i) { | 332 for (size_t i = 0; i < num_iterations; ++i) { |
315 scoped_ptr<data_usage::DataUse> data_use_foo(new data_usage::DataUse( | 333 scoped_ptr<data_usage::DataUse> data_use_foo(new data_usage::DataUse( |
316 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 334 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
317 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1, 2)); | 335 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", |
| 336 external_data_use_observer()->data_use_report_min_bytes_, 1)); |
318 data_use_vector.push_back(data_use_foo.Pass()); | 337 data_use_vector.push_back(data_use_foo.Pass()); |
319 | 338 |
320 scoped_ptr<data_usage::DataUse> data_use_bar(new data_usage::DataUse( | 339 scoped_ptr<data_usage::DataUse> data_use_bar(new data_usage::DataUse( |
321 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 340 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
322 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", 1, 2)); | 341 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", |
| 342 external_data_use_observer()->data_use_report_min_bytes_, 1)); |
323 data_use_vector.push_back(data_use_bar.Pass()); | 343 data_use_vector.push_back(data_use_bar.Pass()); |
324 | 344 |
325 scoped_ptr<data_usage::DataUse> data_use_baz(new data_usage::DataUse( | 345 scoped_ptr<data_usage::DataUse> data_use_baz(new data_usage::DataUse( |
326 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 346 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
327 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_baz", 1, 2)); | 347 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_baz", |
| 348 external_data_use_observer()->data_use_report_min_bytes_, 1)); |
328 data_use_vector.push_back(data_use_baz.Pass()); | 349 data_use_vector.push_back(data_use_baz.Pass()); |
329 } | 350 } |
330 | 351 |
331 std::vector<const data_usage::DataUse*> const_sequence( | 352 std::vector<const data_usage::DataUse*> const_sequence( |
332 data_use_vector.begin(), data_use_vector.end()); | 353 data_use_vector.begin(), data_use_vector.end()); |
333 | 354 |
334 external_data_use_observer()->OnDataUse(const_sequence); | 355 external_data_use_observer()->OnDataUse(const_sequence); |
335 | 356 |
336 EXPECT_EQ(2U, external_data_use_observer()->buffered_data_reports_.size()); | 357 EXPECT_EQ(2U, external_data_use_observer()->buffered_data_reports_.size()); |
337 EXPECT_EQ(static_cast<int64_t>(num_iterations * 2), | 358 EXPECT_EQ(static_cast<int64_t>(num_iterations * 1), |
338 external_data_use_observer() | 359 external_data_use_observer() |
339 ->buffered_data_reports_.begin() | 360 ->buffered_data_reports_.begin() |
340 ->second.bytes_downloaded); | 361 ->second.bytes_downloaded); |
341 EXPECT_EQ(static_cast<int64_t>(num_iterations * 1), | 362 EXPECT_EQ(static_cast<int64_t>( |
| 363 num_iterations * |
| 364 external_data_use_observer()->data_use_report_min_bytes_), |
342 external_data_use_observer() | 365 external_data_use_observer() |
343 ->buffered_data_reports_.begin() | 366 ->buffered_data_reports_.begin() |
344 ->second.bytes_uploaded); | 367 ->second.bytes_uploaded); |
345 | 368 |
346 // Delete the first entry and verify the next entry. | 369 // Delete the first entry and verify the next entry. |
347 external_data_use_observer()->buffered_data_reports_.erase( | 370 external_data_use_observer()->buffered_data_reports_.erase( |
348 external_data_use_observer()->buffered_data_reports_.begin()); | 371 external_data_use_observer()->buffered_data_reports_.begin()); |
349 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); | 372 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); |
350 EXPECT_EQ(static_cast<int64_t>(num_iterations * 2), | 373 EXPECT_EQ(static_cast<int64_t>(num_iterations * 1), |
351 external_data_use_observer() | 374 external_data_use_observer() |
352 ->buffered_data_reports_.begin() | 375 ->buffered_data_reports_.begin() |
353 ->second.bytes_downloaded); | 376 ->second.bytes_downloaded); |
354 EXPECT_EQ(static_cast<int64_t>(num_iterations * 1), | 377 EXPECT_EQ(static_cast<int64_t>( |
| 378 num_iterations * |
| 379 external_data_use_observer()->data_use_report_min_bytes_), |
355 external_data_use_observer() | 380 external_data_use_observer() |
356 ->buffered_data_reports_.begin() | 381 ->buffered_data_reports_.begin() |
357 ->second.bytes_uploaded); | 382 ->second.bytes_uploaded); |
358 } | 383 } |
359 | 384 |
360 // Tests that timestamps of merged reports is correct. | 385 // Tests that timestamps of merged reports is correct. |
361 TEST_F(ExternalDataUseObserverTest, TimestampsMergedCorrectly) { | 386 TEST_F(ExternalDataUseObserverTest, TimestampsMergedCorrectly) { |
362 const std::string label("label"); | 387 const std::string label("label"); |
363 | 388 |
364 std::vector<std::string> url_regexes; | 389 std::vector<std::string> url_regexes; |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
419 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, | 444 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
420 labels); | 445 labels); |
421 EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size()); | 446 EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size()); |
422 EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_); | 447 EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_); |
423 EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_); | 448 EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_); |
424 | 449 |
425 // Check |label_foo| matching rule. | 450 // Check |label_foo| matching rule. |
426 std::vector<const data_usage::DataUse*> data_use_sequence; | 451 std::vector<const data_usage::DataUse*> data_use_sequence; |
427 data_usage::DataUse data_foo_1( | 452 data_usage::DataUse data_foo_1( |
428 GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 453 GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
429 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_1", 0, 0); | 454 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_1", |
| 455 external_data_use_observer()->data_use_report_min_bytes_, 0); |
430 data_usage::DataUse data_foo_2( | 456 data_usage::DataUse data_foo_2( |
431 GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, | 457 GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
432 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_2", 0, 0); | 458 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_2", |
| 459 external_data_use_observer()->data_use_report_min_bytes_, 0); |
433 data_use_sequence.push_back(&data_foo_1); | 460 data_use_sequence.push_back(&data_foo_1); |
434 data_use_sequence.push_back(&data_foo_2); | 461 data_use_sequence.push_back(&data_foo_2); |
435 external_data_use_observer()->OnDataUse(data_use_sequence); | 462 external_data_use_observer()->OnDataUse(data_use_sequence); |
436 | 463 |
437 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); | 464 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); |
438 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); | 465 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); |
439 | 466 |
440 // Verify the label of the data use report. | 467 // Verify the label of the data use report. |
441 EXPECT_EQ(label_foo, external_data_use_observer() | 468 EXPECT_EQ(label_foo, external_data_use_observer() |
442 ->buffered_data_reports_.begin() | 469 ->buffered_data_reports_.begin() |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
477 ExternalDataUseObserver::DataUseReportKey bar_mcc_mnc( | 504 ExternalDataUseObserver::DataUseReportKey bar_mcc_mnc( |
478 "foo_label", net::NetworkChangeNotifier::CONNECTION_UNKNOWN, | 505 "foo_label", net::NetworkChangeNotifier::CONNECTION_UNKNOWN, |
479 "bar_mcc_mnc"); | 506 "bar_mcc_mnc"); |
480 | 507 |
481 EXPECT_NE(hash(foo), hash(bar_label)); | 508 EXPECT_NE(hash(foo), hash(bar_label)); |
482 EXPECT_NE(hash(foo), hash(bar_label)); | 509 EXPECT_NE(hash(foo), hash(bar_label)); |
483 EXPECT_NE(hash(foo), hash(bar_network_type)); | 510 EXPECT_NE(hash(foo), hash(bar_network_type)); |
484 EXPECT_NE(hash(foo), hash(bar_mcc_mnc)); | 511 EXPECT_NE(hash(foo), hash(bar_mcc_mnc)); |
485 } | 512 } |
486 | 513 |
| 514 // Tests if matching rules are fetched periodically. |
| 515 TEST_F(ExternalDataUseObserverTest, PeriodicFetchMatchingRules) { |
| 516 const std::string label("label"); |
| 517 |
| 518 std::vector<std::string> url_regexes; |
| 519 url_regexes.push_back( |
| 520 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
| 521 |
| 522 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
| 523 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
| 524 std::vector<std::string>(url_regexes.size(), label)); |
| 525 |
| 526 EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_); |
| 527 EXPECT_FALSE( |
| 528 external_data_use_observer()->last_matching_rules_fetch_time_.is_null()); |
| 529 |
| 530 std::vector<const data_usage::DataUse*> data_use_sequence; |
| 531 data_usage::DataUse data_use_foo( |
| 532 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
| 533 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", |
| 534 external_data_use_observer()->data_use_report_min_bytes_, 1); |
| 535 data_use_sequence.push_back(&data_use_foo); |
| 536 |
| 537 // Change the time when the fetching rules were fetched. |
| 538 external_data_use_observer()->last_matching_rules_fetch_time_ = |
| 539 base::TimeTicks::Now() - |
| 540 external_data_use_observer()->fetch_matching_rules_duration_; |
| 541 // Matching rules should be expired. |
| 542 EXPECT_GE(base::TimeTicks::Now() - |
| 543 external_data_use_observer()->last_matching_rules_fetch_time_, |
| 544 external_data_use_observer()->fetch_matching_rules_duration_); |
| 545 // OnDataUse should trigger fetching of matching rules. |
| 546 external_data_use_observer()->OnDataUse(data_use_sequence); |
| 547 |
| 548 // Matching rules should not be expired. |
| 549 EXPECT_LT(base::TimeTicks::Now() - |
| 550 external_data_use_observer()->last_matching_rules_fetch_time_, |
| 551 external_data_use_observer()->fetch_matching_rules_duration_); |
| 552 } |
| 553 |
| 554 // Tests if data use reports are sent only after the total bytes send/received |
| 555 // across all buffered reports have reached the specified threshold. |
| 556 TEST_F(ExternalDataUseObserverTest, BufferDataUseReports) { |
| 557 const std::string label("label"); |
| 558 |
| 559 std::vector<std::string> url_regexes; |
| 560 url_regexes.push_back( |
| 561 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
| 562 |
| 563 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
| 564 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
| 565 std::vector<std::string>(url_regexes.size(), label)); |
| 566 |
| 567 // This tests reports 1024 bytes in each loop iteration. For the test to work |
| 568 // properly, |data_use_report_min_bytes_| should be a multiple of 1024. |
| 569 ASSERT_EQ(0, external_data_use_observer()->data_use_report_min_bytes_ % 1024); |
| 570 |
| 571 const size_t num_iterations = |
| 572 external_data_use_observer()->data_use_report_min_bytes_ / 1024; |
| 573 |
| 574 for (size_t i = 0; i < num_iterations; ++i) { |
| 575 ScopedVector<data_usage::DataUse> data_use_vector; |
| 576 |
| 577 scoped_ptr<data_usage::DataUse> data_use_foo(new data_usage::DataUse( |
| 578 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
| 579 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1024, 0)); |
| 580 data_use_vector.push_back(data_use_foo.Pass()); |
| 581 |
| 582 std::vector<const data_usage::DataUse*> const_sequence( |
| 583 data_use_vector.begin(), data_use_vector.end()); |
| 584 |
| 585 external_data_use_observer()->OnDataUse(const_sequence); |
| 586 if (i != num_iterations - 1) { |
| 587 // Total buffered bytes is less than the minimum threshold. Data use |
| 588 // report should not be send. |
| 589 EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_); |
| 590 EXPECT_EQ(i + 1, |
| 591 external_data_use_observer()->total_bytes_buffered_ / 1024); |
| 592 |
| 593 } else { |
| 594 // Total bytes is at least the minimum threshold. This should trigger |
| 595 // submitting of the buffered data use report. |
| 596 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); |
| 597 EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_); |
| 598 } |
| 599 } |
| 600 EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_); |
| 601 } |
| 602 |
| 603 // Tests if the parameters from the field trial are populated correctly. |
| 604 TEST_F(ExternalDataUseObserverTest, Variations) { |
| 605 EXPECT_EQ(base::TimeDelta::FromSeconds(60 * 15), |
| 606 external_data_use_observer()->fetch_matching_rules_duration_); |
| 607 EXPECT_EQ(100 * 1024, |
| 608 external_data_use_observer()->data_use_report_min_bytes_); |
| 609 |
| 610 variations::testing::ClearAllVariationParams(); |
| 611 std::map<std::string, std::string> variation_params; |
| 612 |
| 613 const int fetch_matching_rules_duration_seconds = 10000; |
| 614 const int data_use_report_min_bytes = 5000; |
| 615 variation_params["fetch_matching_rules_duration_seconds"] = |
| 616 base::Int64ToString(fetch_matching_rules_duration_seconds); |
| 617 variation_params["data_use_report_min_bytes"] = |
| 618 base::Int64ToString(data_use_report_min_bytes); |
| 619 |
| 620 ASSERT_TRUE(variations::AssociateVariationParams( |
| 621 external_data_use_observer()->GetExternalDataUseObserverFieldTrialName(), |
| 622 "Enabled", variation_params)); |
| 623 |
| 624 base::FieldTrialList field_trial_list(nullptr); |
| 625 base::FieldTrialList::CreateFieldTrial( |
| 626 external_data_use_observer()->GetExternalDataUseObserverFieldTrialName(), |
| 627 "Enabled"); |
| 628 |
| 629 // Create another ExternalDataUseObserver object. This would fetch variation |
| 630 // params. |
| 631 scoped_ptr<ExternalDataUseObserver> |
| 632 external_data_use_obsever_with_variations = Create(); |
| 633 EXPECT_EQ(base::TimeDelta::FromSeconds(fetch_matching_rules_duration_seconds), |
| 634 external_data_use_obsever_with_variations |
| 635 ->fetch_matching_rules_duration_); |
| 636 EXPECT_EQ( |
| 637 data_use_report_min_bytes, |
| 638 external_data_use_obsever_with_variations->data_use_report_min_bytes_); |
| 639 } |
| 640 |
487 } // namespace android | 641 } // namespace android |
488 | 642 |
489 } // namespace chrome | 643 } // namespace chrome |
OLD | NEW |