Show password sync status in CBD

chrome/browser/browsing_data/passwords_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/passwords_counter.h"
 
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/test/integration/passwords_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/autofill/core/common/password_form.h"
+#include "components/browser_sync/profile_sync_service_mock.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 {
 
 using autofill::PasswordForm;
 
 class PasswordsCounterTest : public InProcessBrowserTest {
@@ skipping 52 matching lines @@
     // we get a finished result.
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
   browsing_data::BrowsingDataCounter::ResultInt GetResult() {
     DCHECK(finished_);
     return result_;
   }
 
+  bool HasSyncedPasswords() {
+    DCHECK(finished_);
+    return has_synced_passwords_;
+  }
+
   void Callback(
       std::unique_ptr<browsing_data::BrowsingDataCounter::Result> result) {
     finished_ = result->Finished();
 
     if (finished_) {
-      result_ =
-          static_cast<browsing_data::BrowsingDataCounter::FinishedResult*>(
-              result.get())
-              ->Value();
+      auto* password_result =
+          static_cast<browsing_data::PasswordsCounter::PasswordResult*>(
+              result.get());
+      result_ = password_result->Value();
+      has_synced_passwords_ = password_result->has_synced_passwords();
     }
 
     if (finished_)
       run_loop_->Quit();
   }
 
   void WaitForUICallbacksFromAddingLogins() {
     base::RunLoop loop;
     loop.RunUntilIdle();
   }
@@ skipping 12 matching lines @@
     return result;
   }
 
   scoped_refptr<password_manager::PasswordStore> store_;
 
   std::unique_ptr<base::RunLoop> run_loop_;
   base::Time time_;
 
   bool finished_;
   browsing_data::BrowsingDataCounter::ResultInt result_;
+  bool has_synced_passwords_;
 };
 
 // Tests that the counter correctly counts each individual credential on
 // the same domain.
 IN_PROC_BROWSER_TEST_F(PasswordsCounterTest, SameDomain) {
   AddLogin("https://www.google.com", "user1", false);
   AddLogin("https://www.google.com", "user2", false);
   AddLogin("https://www.google.com", "user3", false);
   AddLogin("https://www.chrome.com", "user1", false);
   AddLogin("https://www.chrome.com", "user2", false);
   WaitForUICallbacksFromAddingLogins();
 
   Profile* profile = browser()->profile();
-  browsing_data::PasswordsCounter counter(PasswordStoreFactory::GetForProfile(
-      profile, ServiceAccessType::EXPLICIT_ACCESS));
+  browsing_data::PasswordsCounter counter(
+      PasswordStoreFactory::GetForProfile(profile,
+                                          ServiceAccessType::EXPLICIT_ACCESS),
+      ProfileSyncServiceFactory::GetForProfile(profile));
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&PasswordsCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
 
   WaitForCounting();
   EXPECT_EQ(5u, GetResult());
+  EXPECT_EQ(false, HasSyncedPasswords());
 }
 
 // Tests that the counter doesn't count blacklisted entries.
 IN_PROC_BROWSER_TEST_F(PasswordsCounterTest, Blacklisted) {
   AddLogin("https://www.google.com", "user1", false);
   AddLogin("https://www.google.com", "user2", true);
   AddLogin("https://www.chrome.com", "user3", true);
   WaitForUICallbacksFromAddingLogins();
 
   Profile* profile = browser()->profile();
-  browsing_data::PasswordsCounter counter(PasswordStoreFactory::GetForProfile(
-      profile, ServiceAccessType::EXPLICIT_ACCESS));
+  browsing_data::PasswordsCounter counter(
+      PasswordStoreFactory::GetForProfile(profile,
+                                          ServiceAccessType::EXPLICIT_ACCESS),
+      ProfileSyncServiceFactory::GetForProfile(profile));
 
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&PasswordsCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
 
   WaitForCounting();
   EXPECT_EQ(1u, GetResult());
+  EXPECT_EQ(false, HasSyncedPasswords());
 }
 
 // Tests that the counter starts counting automatically when the deletion
 // pref changes to true.
 IN_PROC_BROWSER_TEST_F(PasswordsCounterTest, PrefChanged) {
   SetPasswordsDeletionPref(false);
   AddLogin("https://www.google.com", "user", false);
   AddLogin("https://www.chrome.com", "user", false);
   WaitForUICallbacksFromAddingLogins();
 
   Profile* profile = browser()->profile();
-  browsing_data::PasswordsCounter counter(PasswordStoreFactory::GetForProfile(
-      profile, ServiceAccessType::EXPLICIT_ACCESS));
+  browsing_data::PasswordsCounter counter(
+      PasswordStoreFactory::GetForProfile(profile,
+                                          ServiceAccessType::EXPLICIT_ACCESS),
+      ProfileSyncServiceFactory::GetForProfile(profile));
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&PasswordsCounterTest::Callback, base::Unretained(this)));
   SetPasswordsDeletionPref(true);
 
   WaitForCounting();
   EXPECT_EQ(2u, GetResult());
+  EXPECT_EQ(false, HasSyncedPasswords());
 }
 
 // Tests that the counter starts counting automatically when
 // the password store changes.
 IN_PROC_BROWSER_TEST_F(PasswordsCounterTest, StoreChanged) {
   AddLogin("https://www.google.com", "user", false);
   WaitForUICallbacksFromAddingLogins();
 
   Profile* profile = browser()->profile();
-  browsing_data::PasswordsCounter counter(PasswordStoreFactory::GetForProfile(
-      profile, ServiceAccessType::EXPLICIT_ACCESS));
+  browsing_data::PasswordsCounter counter(
+      PasswordStoreFactory::GetForProfile(profile,
+                                          ServiceAccessType::EXPLICIT_ACCESS),
+      ProfileSyncServiceFactory::GetForProfile(profile));
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&PasswordsCounterTest::Callback, base::Unretained(this)));
   counter.Restart();
 
   WaitForCounting();
   EXPECT_EQ(1u, GetResult());
 
   AddLogin("https://www.chrome.com", "user", false);
   WaitForCounting();
@@ skipping 10 matching lines @@
   AddLogin("https://www.google.com", "user", false);
   RevertTimeInDays(2);
   AddLogin("https://example.com", "user1", false);
   RevertTimeInDays(3);
   AddLogin("https://example.com", "user2", false);
   RevertTimeInDays(30);
   AddLogin("https://www.chrome.com", "user", false);
   WaitForUICallbacksFromAddingLogins();
 
   Profile* profile = browser()->profile();
-  browsing_data::PasswordsCounter counter(PasswordStoreFactory::GetForProfile(
-      profile, ServiceAccessType::EXPLICIT_ACCESS));
+  browsing_data::PasswordsCounter counter(
+      PasswordStoreFactory::GetForProfile(profile,
+                                          ServiceAccessType::EXPLICIT_ACCESS),
+      ProfileSyncServiceFactory::GetForProfile(profile));
   counter.Init(
       profile->GetPrefs(), browsing_data::ClearBrowsingDataTab::ADVANCED,
       base::Bind(&PasswordsCounterTest::Callback, base::Unretained(this)));
 
   SetDeletionPeriodPref(browsing_data::TimePeriod::LAST_HOUR);
   WaitForCounting();
   EXPECT_EQ(1u, GetResult());
 
   SetDeletionPeriodPref(browsing_data::TimePeriod::LAST_DAY);
   WaitForCounting();
   EXPECT_EQ(1u, GetResult());
 
   SetDeletionPeriodPref(browsing_data::TimePeriod::LAST_WEEK);
   WaitForCounting();
   EXPECT_EQ(3u, GetResult());
 
   SetDeletionPeriodPref(browsing_data::TimePeriod::FOUR_WEEKS);
   WaitForCounting();
   EXPECT_EQ(3u, GetResult());
 
   SetDeletionPeriodPref(browsing_data::TimePeriod::ALL_TIME);
   WaitForCounting();
   EXPECT_EQ(4u, GetResult());
 }
 
 }  // namespace