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 172 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
224 std::vector<std::string>(url_regexes.size(), "label")); | 232 std::vector<std::string>(url_regexes.size(), "label")); |
225 EXPECT_FALSE(external_data_use_observer()->Matches(GURL(""), &label)); | 233 EXPECT_FALSE(external_data_use_observer()->Matches(GURL(""), &label)); |
226 EXPECT_FALSE(external_data_use_observer()->Matches( | 234 EXPECT_FALSE(external_data_use_observer()->Matches( |
227 GURL("http://www.google.com#q=abc"), &label)); | 235 GURL("http://www.google.com#q=abc"), &label)); |
228 EXPECT_TRUE(external_data_use_observer()->Matches( | 236 EXPECT_TRUE(external_data_use_observer()->Matches( |
229 GURL("http://www.google.co.in#q=abc"), &label)); | 237 GURL("http://www.google.co.in#q=abc"), &label)); |
230 } | 238 } |
231 | 239 |
232 // Tests that at most one data use request is submitted. | 240 // Tests that at most one data use request is submitted. |
233 TEST_F(ExternalDataUseObserverTest, AtMostOneDataUseSubmitRequest) { | 241 TEST_F(ExternalDataUseObserverTest, AtMostOneDataUseSubmitRequest) { |
| 242 external_data_use_observer()->data_use_report_min_bytes_ = 0; |
234 const std::string label("label"); | 243 const std::string label("label"); |
235 | 244 |
236 std::vector<std::string> url_regexes; | 245 std::vector<std::string> url_regexes; |
237 url_regexes.push_back( | 246 url_regexes.push_back( |
238 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); | 247 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
239 | 248 |
240 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( | 249 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
241 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, | 250 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
242 std::vector<std::string>(url_regexes.size(), label)); | 251 std::vector<std::string>(url_regexes.size(), label)); |
243 EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size()); | 252 EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size()); |
(...skipping 10 matching lines...) Expand all Loading... |
254 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", 1, 2); | 263 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", 1, 2); |
255 data_use_sequence.push_back(&data_use_bar); | 264 data_use_sequence.push_back(&data_use_bar); |
256 external_data_use_observer()->OnDataUse(data_use_sequence); | 265 external_data_use_observer()->OnDataUse(data_use_sequence); |
257 | 266 |
258 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); | 267 EXPECT_EQ(1U, external_data_use_observer()->buffered_data_reports_.size()); |
259 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); | 268 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); |
260 } | 269 } |
261 | 270 |
262 // Verifies that buffer size does not exceed the specified limit. | 271 // Verifies that buffer size does not exceed the specified limit. |
263 TEST_F(ExternalDataUseObserverTest, BufferSize) { | 272 TEST_F(ExternalDataUseObserverTest, BufferSize) { |
| 273 external_data_use_observer()->data_use_report_min_bytes_ = 0; |
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((max_buffer_size - 1) * (bytes_downloaded + bytes_uploaded), |
| 307 external_data_use_observer()->total_bytes_buffered_); |
291 EXPECT_EQ(max_buffer_size - 1, | 308 EXPECT_EQ(max_buffer_size - 1, |
292 external_data_use_observer()->buffered_data_reports_.size()); | 309 external_data_use_observer()->buffered_data_reports_.size()); |
293 | 310 |
294 // Verify the label of the data use report. | 311 // Verify the label of the data use report. |
295 for (const auto& it : external_data_use_observer()->buffered_data_reports_) | 312 for (const auto& it : external_data_use_observer()->buffered_data_reports_) |
296 EXPECT_EQ(label, it.first.label); | 313 EXPECT_EQ(label, it.first.label); |
297 } | 314 } |
298 | 315 |
299 // Tests that buffered data use reports are merged correctly. | 316 // Tests that buffered data use reports are merged correctly. |
300 TEST_F(ExternalDataUseObserverTest, ReportsMergedCorrectly) { | 317 TEST_F(ExternalDataUseObserverTest, ReportsMergedCorrectly) { |
| 318 external_data_use_observer()->data_use_report_min_bytes_ = 0; |
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 |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
396 ->second.start_time.ToJavaTime()); | 414 ->second.start_time.ToJavaTime()); |
397 // Convert from seconds to milliseconds. | 415 // Convert from seconds to milliseconds. |
398 EXPECT_EQ(static_cast<int64_t>(num_iterations * 1000), | 416 EXPECT_EQ(static_cast<int64_t>(num_iterations * 1000), |
399 external_data_use_observer() | 417 external_data_use_observer() |
400 ->buffered_data_reports_.begin() | 418 ->buffered_data_reports_.begin() |
401 ->second.end_time.ToJavaTime()); | 419 ->second.end_time.ToJavaTime()); |
402 } | 420 } |
403 | 421 |
404 // Tests the behavior when multiple matching rules are available. | 422 // Tests the behavior when multiple matching rules are available. |
405 TEST_F(ExternalDataUseObserverTest, MultipleMatchingRules) { | 423 TEST_F(ExternalDataUseObserverTest, MultipleMatchingRules) { |
| 424 external_data_use_observer()->data_use_report_min_bytes_ = 0; |
406 std::vector<std::string> url_regexes; | 425 std::vector<std::string> url_regexes; |
407 url_regexes.push_back( | 426 url_regexes.push_back( |
408 "http://www[.]foo[.]com/#q=.*|https://www[.]foo[.]com/#q=.*"); | 427 "http://www[.]foo[.]com/#q=.*|https://www[.]foo[.]com/#q=.*"); |
409 url_regexes.push_back( | 428 url_regexes.push_back( |
410 "http://www[.]bar[.]com/#q=.*|https://www[.]bar[.]com/#q=.*"); | 429 "http://www[.]bar[.]com/#q=.*|https://www[.]bar[.]com/#q=.*"); |
411 | 430 |
412 std::vector<std::string> labels; | 431 std::vector<std::string> labels; |
413 const std::string label_foo("label_foo"); | 432 const std::string label_foo("label_foo"); |
414 const std::string label_bar("label_bar"); | 433 const std::string label_bar("label_bar"); |
415 labels.push_back(label_foo); | 434 labels.push_back(label_foo); |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
477 ExternalDataUseObserver::DataUseReportKey bar_mcc_mnc( | 496 ExternalDataUseObserver::DataUseReportKey bar_mcc_mnc( |
478 "foo_label", net::NetworkChangeNotifier::CONNECTION_UNKNOWN, | 497 "foo_label", net::NetworkChangeNotifier::CONNECTION_UNKNOWN, |
479 "bar_mcc_mnc"); | 498 "bar_mcc_mnc"); |
480 | 499 |
481 EXPECT_NE(hash(foo), hash(bar_label)); | 500 EXPECT_NE(hash(foo), hash(bar_label)); |
482 EXPECT_NE(hash(foo), hash(bar_label)); | 501 EXPECT_NE(hash(foo), hash(bar_label)); |
483 EXPECT_NE(hash(foo), hash(bar_network_type)); | 502 EXPECT_NE(hash(foo), hash(bar_network_type)); |
484 EXPECT_NE(hash(foo), hash(bar_mcc_mnc)); | 503 EXPECT_NE(hash(foo), hash(bar_mcc_mnc)); |
485 } | 504 } |
486 | 505 |
| 506 // Tests if matching rules are fetched periodically. |
| 507 TEST_F(ExternalDataUseObserverTest, PeriodicFetchMatchingRules) { |
| 508 external_data_use_observer()->data_use_report_min_bytes_ = 0; |
| 509 const std::string label("label"); |
| 510 |
| 511 std::vector<std::string> url_regexes; |
| 512 url_regexes.push_back( |
| 513 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
| 514 |
| 515 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
| 516 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
| 517 std::vector<std::string>(url_regexes.size(), label)); |
| 518 |
| 519 EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_); |
| 520 EXPECT_FALSE( |
| 521 external_data_use_observer()->last_matching_rules_fetch_time_.is_null()); |
| 522 |
| 523 std::vector<const data_usage::DataUse*> data_use_sequence; |
| 524 data_usage::DataUse data_use_foo( |
| 525 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
| 526 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1, 2); |
| 527 data_use_sequence.push_back(&data_use_foo); |
| 528 |
| 529 // Change the time when the fetching rules were fetched. |
| 530 external_data_use_observer()->last_matching_rules_fetch_time_ = |
| 531 base::TimeTicks::Now() - |
| 532 external_data_use_observer()->fetch_matching_rules_duration_; |
| 533 // Matching rules should be expired. |
| 534 EXPECT_GE(base::TimeTicks::Now() - |
| 535 external_data_use_observer()->last_matching_rules_fetch_time_, |
| 536 external_data_use_observer()->fetch_matching_rules_duration_); |
| 537 // OnDataUse should trigger fetching of matching rules. |
| 538 external_data_use_observer()->OnDataUse(data_use_sequence); |
| 539 |
| 540 // Matching rules should not be expired. |
| 541 EXPECT_LT(base::TimeTicks::Now() - |
| 542 external_data_use_observer()->last_matching_rules_fetch_time_, |
| 543 external_data_use_observer()->fetch_matching_rules_duration_); |
| 544 } |
| 545 |
| 546 // Tests if data use reports are sent only after the total bytes send/received |
| 547 // across all buffered reports have reached the specified threshold. |
| 548 TEST_F(ExternalDataUseObserverTest, BufferDataUseReports) { |
| 549 const std::string label("label"); |
| 550 |
| 551 std::vector<std::string> url_regexes; |
| 552 url_regexes.push_back( |
| 553 "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*"); |
| 554 |
| 555 external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread( |
| 556 std::vector<std::string>(url_regexes.size(), std::string()), url_regexes, |
| 557 std::vector<std::string>(url_regexes.size(), label)); |
| 558 |
| 559 // This tests reports 1000 bytes in each loop iteration. For the test to work |
| 560 // properly, |data_use_report_min_bytes_| should be a multiple of 1000. |
| 561 ASSERT_EQ(0, external_data_use_observer()->data_use_report_min_bytes_ % 1000); |
| 562 |
| 563 const size_t num_iterations = |
| 564 external_data_use_observer()->data_use_report_min_bytes_ / 1000; |
| 565 |
| 566 for (size_t i = 0; i < num_iterations; ++i) { |
| 567 ScopedVector<data_usage::DataUse> data_use_vector; |
| 568 |
| 569 scoped_ptr<data_usage::DataUse> data_use_foo(new data_usage::DataUse( |
| 570 GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0, |
| 571 net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1000, 0)); |
| 572 data_use_vector.push_back(data_use_foo.Pass()); |
| 573 |
| 574 std::vector<const data_usage::DataUse*> const_sequence( |
| 575 data_use_vector.begin(), data_use_vector.end()); |
| 576 |
| 577 external_data_use_observer()->OnDataUse(const_sequence); |
| 578 if (i != num_iterations - 1) { |
| 579 // Total buffered bytes is less than the minimum threshold. Data use |
| 580 // report should not be send. |
| 581 EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_); |
| 582 EXPECT_EQ(i + 1, |
| 583 external_data_use_observer()->total_bytes_buffered_ / 1000); |
| 584 |
| 585 } else { |
| 586 // Total bytes is at least the minimum threshold. This should trigger |
| 587 // submitting of the buffered data use report. |
| 588 EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_); |
| 589 EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_); |
| 590 } |
| 591 } |
| 592 EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_); |
| 593 } |
| 594 |
| 595 // Tests if the parameters from the field trial are populated correctly. |
| 596 TEST_F(ExternalDataUseObserverTest, Variations) { |
| 597 EXPECT_EQ(base::TimeDelta::FromSeconds(60 * 15), |
| 598 external_data_use_observer()->fetch_matching_rules_duration_); |
| 599 EXPECT_EQ(100 * 1000, |
| 600 external_data_use_observer()->data_use_report_min_bytes_); |
| 601 |
| 602 variations::testing::ClearAllVariationParams(); |
| 603 std::map<std::string, std::string> variation_params; |
| 604 |
| 605 const int fetch_matching_rules_duration_seconds = 10000; |
| 606 const int data_use_report_min_bytes = 5000; |
| 607 variation_params["fetch_matching_rules_duration_seconds"] = |
| 608 base::Int64ToString(fetch_matching_rules_duration_seconds); |
| 609 variation_params["data_use_report_min_bytes"] = |
| 610 base::Int64ToString(data_use_report_min_bytes); |
| 611 |
| 612 ASSERT_TRUE(variations::AssociateVariationParams( |
| 613 external_data_use_observer()->GetExternalDataUseObserverFieldTrialName(), |
| 614 "Enabled", variation_params)); |
| 615 |
| 616 base::FieldTrialList field_trial_list(nullptr); |
| 617 base::FieldTrialList::CreateFieldTrial( |
| 618 external_data_use_observer()->GetExternalDataUseObserverFieldTrialName(), |
| 619 "Enabled"); |
| 620 |
| 621 // Create another ExternalDataUseObserver object. This would fetch variation |
| 622 // params. |
| 623 scoped_ptr<ExternalDataUseObserver> |
| 624 external_data_use_obsever_with_variations = Create(); |
| 625 EXPECT_EQ(base::TimeDelta::FromSeconds(fetch_matching_rules_duration_seconds), |
| 626 external_data_use_obsever_with_variations |
| 627 ->fetch_matching_rules_duration_); |
| 628 EXPECT_EQ( |
| 629 data_use_report_min_bytes, |
| 630 external_data_use_obsever_with_variations->data_use_report_min_bytes_); |
| 631 } |
| 632 |
487 } // namespace android | 633 } // namespace android |
488 | 634 |
489 } // namespace chrome | 635 } // namespace chrome |
OLD | NEW |