Show autofill sync status in CBD

chrome/browser/browsing_data/autofill_counter_browsertest.cc

 // Copyright (c) 2015 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 "components/browsing_data/core/counters/autofill_counter.h"
 
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/sync/test/integration/sync_test.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/web_data_service_factory.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
+#include "components/browser_sync/profile_sync_service.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
 #include "components/browsing_data/core/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace {
 
-class AutofillCounterTest : public InProcessBrowserTest {
+// TODO(crbug.com/553421): Only RestartOnSyncChange is a SyncTest.
+// Extract it together with HistoryCounterTest.RestartOnSyncChange.
+class AutofillCounterTest : public SyncTest {
  public:
-  AutofillCounterTest() {}
+  AutofillCounterTest() : SyncTest(SINGLE_CLIENT) {}
   ~AutofillCounterTest() override {}
 
   void SetUpOnMainThread() override {
     web_data_service_ = WebDataServiceFactory::GetAutofillWebDataForProfile(
         browser()->profile(), ServiceAccessType::IMPLICIT_ACCESS);
 
     SetAutofillDeletionPref(true);
     SetDeletionPeriodPref(browsing_data::TimePeriod::ALL_TIME);
   }
 
@@ skipping 103 matching lines @@
     return web_data_service_;
   }
 
   // Callback and result retrieval ---------------------------------------------
 
   void WaitForCounting() {
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
+  bool CountingFinishedSinceLastAsked() {

[msramek, 2017/04/28 19:13:13]

This is starting to look like we'll need BrowsingDataCounterTestBase. Can you
add a TODO or file a bug?

+    bool result = finished_;
+    finished_ = false;
+    return result;
+  }
+
+  void WaitForCountingOrConfirmFinished() {
+    if (CountingFinishedSinceLastAsked())
+      return;
+
+    WaitForCounting();
+    CountingFinishedSinceLastAsked();
+  }
+
   browsing_data::BrowsingDataCounter::ResultInt GetNumSuggestions() {
     DCHECK(finished_);
     return num_suggestions_;
   }
 
   browsing_data::BrowsingDataCounter::ResultInt GetNumCreditCards() {
     DCHECK(finished_);
     return num_credit_cards_;
   }
 
   browsing_data::BrowsingDataCounter::ResultInt GetNumAddresses() {
     DCHECK(finished_);
     return num_addresses_;
   }
 
+  bool AutofillSyncEnabled() { return autofill_sync_enabled_; }
+
   void Callback(
       std::unique_ptr<browsing_data::BrowsingDataCounter::Result> result) {
     finished_ = result->Finished();
 
     if (finished_) {
       browsing_data::AutofillCounter::AutofillResult* autofill_result =
           static_cast<browsing_data::AutofillCounter::AutofillResult*>(
               result.get());
 
       num_suggestions_ = autofill_result->Value();
       num_credit_cards_ = autofill_result->num_credit_cards();
       num_addresses_ = autofill_result->num_addresses();
+      autofill_sync_enabled_ = autofill_result->autofill_sync_enabled();
     }
 
     if (run_loop_ && finished_)
       run_loop_->Quit();
   }
 
  private:
   std::unique_ptr<base::RunLoop> run_loop_;
 
   std::vector<std::string> credit_card_ids_;
   std::vector<std::string> address_ids_;
 
   scoped_refptr<autofill::AutofillWebDataService> web_data_service_;
 
   bool finished_;
   browsing_data::BrowsingDataCounter::ResultInt num_suggestions_;
   browsing_data::BrowsingDataCounter::ResultInt num_credit_cards_;
   browsing_data::BrowsingDataCounter::ResultInt num_addresses_;
+  bool autofill_sync_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(AutofillCounterTest);
 };
 
 // Tests that we count the correct number of autocomplete suggestions.
 IN_PROC_BROWSER_TEST_F(AutofillCounterTest, AutocompleteSuggestions) {
   Profile* profile = browser()->profile();
-  browsing_data::AutofillCounter counter(GetWebDataService());
+  browsing_data::AutofillCounter counter(GetWebDataService(), nullptr);
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&AutofillCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0, GetNumSuggestions());
 
   AddAutocompleteSuggestion("email", "example@example.com");
   counter.Restart();
   WaitForCounting();
@@ skipping 16 matching lines @@
 
   ClearAutocompleteSuggestions();
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0, GetNumSuggestions());
 }
 
 // Tests that we count the correct number of credit cards.
 IN_PROC_BROWSER_TEST_F(AutofillCounterTest, CreditCards) {
   Profile* profile = browser()->profile();
-  browsing_data::AutofillCounter counter(GetWebDataService());
+  browsing_data::AutofillCounter counter(GetWebDataService(), nullptr);
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&AutofillCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0, GetNumCreditCards());
 
   AddCreditCard("0000-0000-0000-0000", "1", "2015");
   counter.Restart();
   WaitForCounting();
@@ skipping 16 matching lines @@
 
   ClearCreditCardsAndAddresses();
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0, GetNumCreditCards());
 }
 
 // Tests that we count the correct number of addresses.
 IN_PROC_BROWSER_TEST_F(AutofillCounterTest, Addresses) {
   Profile* profile = browser()->profile();
-  browsing_data::AutofillCounter counter(GetWebDataService());
+  browsing_data::AutofillCounter counter(GetWebDataService(), nullptr);
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&AutofillCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0, GetNumAddresses());
 
   AddAddress("John", "Doe", "Main Street 12345");
   counter.Restart();
   WaitForCounting();
@@ skipping 30 matching lines @@
   AddAutocompleteSuggestion("city", "Munich");
 
   AddCreditCard("0000-0000-0000-0000", "1", "2015");
   AddCreditCard("1211-1098-7654-3210", "10", "2030");
 
   AddAddress("John", "Doe", "Main Street 12345");
   AddAddress("Jane", "Smith", "Main Street 12346");
   AddAddress("John", "Smith", "Side Street 47");
 
   Profile* profile = browser()->profile();
-  browsing_data::AutofillCounter counter(GetWebDataService());
+  browsing_data::AutofillCounter counter(GetWebDataService(), nullptr);
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&AutofillCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(5, GetNumSuggestions());
   EXPECT_EQ(2, GetNumCreditCards());
   EXPECT_EQ(3, GetNumAddresses());
 }
 
@@ skipping 35 matching lines @@
         expected_num_credit_cards;
     const browsing_data::BrowsingDataCounter::ResultInt expected_num_addresses;
   } test_cases[] = {
     { base::Time(), 2, 3, 3},
     { time1,        2, 3, 3},
     { time2,        1, 2, 2},
     { time3,        1, 1, 0}
   };
 
   Profile* profile = browser()->profile();
-  browsing_data::AutofillCounter counter(GetWebDataService());
+  browsing_data::AutofillCounter counter(GetWebDataService(), nullptr);
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&AutofillCounterTest::Callback, base::Unretained(this)));
 
   for (const TestCase& test_case : test_cases) {
     counter.SetPeriodStartForTesting(test_case.period_start);
     counter.Restart();
     WaitForCounting();
     EXPECT_EQ(test_case.expected_num_suggestions, GetNumSuggestions());
     EXPECT_EQ(test_case.expected_num_credit_cards, GetNumCreditCards());
     EXPECT_EQ(test_case.expected_num_addresses, GetNumAddresses());
   }
 }
 
+// Test that the counting restarts when autofill sync state changes.
+// TODO(crbug.com/553421): Move this to the sync/test/integration directory?
+IN_PROC_BROWSER_TEST_F(AutofillCounterTest, RestartOnSyncChange) {
+  // Set up the Sync client.
+  ASSERT_TRUE(SetupClients());
+  static const int kFirstProfileIndex = 0;
+  browser_sync::ProfileSyncService* sync_service =
+      GetSyncService(kFirstProfileIndex);
+  Profile* profile = GetProfile(kFirstProfileIndex);
+  // Set up the counter.
+  browsing_data::AutofillCounter counter(
+      WebDataServiceFactory::GetAutofillWebDataForProfile(
+          profile, ServiceAccessType::IMPLICIT_ACCESS),
+      sync_service);
+
+  counter.Init(
+      profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
+      base::Bind(&AutofillCounterTest::Callback, base::Unretained(this)));
+
+  // Note that some Sync operations notify observers immediately (and thus there
+  // is no need to call |WaitForCounting()|; in fact, it would block the test),
+  // while other operations only post the task on UI thread's message loop
+  // (which requires calling |WaitForCounting()| for them to run). Therefore,
+  // this test always checks if the callback has already run and only waits
+  // if it has not.
+
+  // We sync all datatypes by default, so starting Sync means that we start
+  // syncing autofill, and this should restart the counter.
+  ASSERT_TRUE(SetupSync());
+  ASSERT_TRUE(sync_service->IsSyncActive());
+  ASSERT_TRUE(sync_service->GetActiveDataTypes().Has(syncer::AUTOFILL));
+  WaitForCountingOrConfirmFinished();
+  EXPECT_TRUE(AutofillSyncEnabled());
+
+  // We stop syncing autofill in particular. This restarts the counter.
+  syncer::ModelTypeSet everything_except_autofill =
+      syncer::UserSelectableTypes();
+  everything_except_autofill.Remove(syncer::AUTOFILL);
+  auto sync_blocker = sync_service->GetSetupInProgressHandle();
+  sync_service->OnUserChoseDatatypes(/*sync_everything=*/false,
+                                     everything_except_autofill);
+  ASSERT_FALSE(sync_service->GetPreferredDataTypes().Has(syncer::AUTOFILL));
+  sync_blocker.reset();
+  WaitForCountingOrConfirmFinished();
+  ASSERT_FALSE(sync_service->GetActiveDataTypes().Has(syncer::AUTOFILL));
+  EXPECT_FALSE(AutofillSyncEnabled());
+
+  // If autofill sync is not affected, the counter is not restarted.
+  syncer::ModelTypeSet only_history(syncer::HISTORY_DELETE_DIRECTIVES);
+  sync_blocker = sync_service->GetSetupInProgressHandle();
+  sync_service->ChangePreferredDataTypes(only_history);
+  sync_blocker.reset();
+  EXPECT_FALSE(CountingFinishedSinceLastAsked());
+
+  // We start syncing autofill again. This restarts the counter.
+  sync_blocker = sync_service->GetSetupInProgressHandle();
+  sync_service->ChangePreferredDataTypes(syncer::ModelTypeSet::All());
+  sync_blocker.reset();
+  WaitForCountingOrConfirmFinished();
+  EXPECT_TRUE(AutofillSyncEnabled());
+
+  // Stopping the Sync service triggers a restart.
+  sync_service->RequestStop(syncer::SyncService::CLEAR_DATA);
+  WaitForCountingOrConfirmFinished();
+  EXPECT_FALSE(AutofillSyncEnabled());
+}
+
 }  // namespace