[BrowserSwitcher] Deflake BrowserSwitcherServiceTest

Previously, the tests waited for action_timeout(), to wait for LBS to
load the rules and write some files. As expected, this is fairly flaky,
and it slows down the tests.

Now, `BrowserSwitcherService' exposes a new event for testing, which
fires once LBS has loaded the rules. This should reduce flakes by
listening for the event instead of using an unreliable timeout.

Also rewrote some tests in a synchronous style, which improves
readability.

Bug: 1044619, 1070400
Change-Id: If1a2093cfe3bface73a46896ff2bc95b80ab2f2e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2152885
Commit-Queue: Nicolas Ouellet-Payeur <nicolaso@chromium.org>
Reviewed-by: Julian Pastarmov <pastarmovj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#760531}

chrome/browser/browser_switcher/browser_switcher_service.cc

@@ -239,6 +239,11 @@ void BrowserSwitcherService::Init() {
   StartDownload(fetch_delay());
 }
 
+void BrowserSwitcherService::OnAllRulesetsLoadedForTesting(
+    base::OnceCallback<void()> cb) {
+  all_rulesets_loaded_callback_for_testing_ = std::move(cb);
+}
+
 void BrowserSwitcherService::StartDownload(base::TimeDelta delay) {
   // This destroys the previous XmlDownloader, which cancels any scheduled
   // refresh operations.
@@ -319,6 +324,8 @@ void BrowserSwitcherService::LoadRulesFromPrefs() {
 
 void BrowserSwitcherService::OnAllRulesetsParsed() {
   callback_list_.Notify(this);
+  if (all_rulesets_loaded_callback_for_testing_)
+    std::move(all_rulesets_loaded_callback_for_testing_).Run();
 }
 
 std::unique_ptr<BrowserSwitcherService::CallbackSubscription>

chrome/browser/browser_switcher/browser_switcher_service.h

@@ -124,6 +124,8 @@ class BrowserSwitcherService : public KeyedService {
   explicit BrowserSwitcherService(Profile* profile);
   ~BrowserSwitcherService() override;
 
+  virtual void Init();
+
   // KeyedService:
   void Shutdown() override;
 
@@ -149,7 +151,10 @@ class BrowserSwitcherService : public KeyedService {
   // happens.
   virtual void LoadRulesFromPrefs();
 
-  void Init();
+  // Called after all XML rulesets finished downloading, and the rules are
+  // applied. The XML is downloaded asynchronously, so browser tests use this
+  // event to check that they applied correctly.
+  void OnAllRulesetsLoadedForTesting(base::OnceCallback<void()> callback);
 
  protected:
   virtual void OnAllRulesetsParsed();
@@ -194,6 +199,8 @@ class BrowserSwitcherService : public KeyedService {
   // CallbackList for OnAllRulesetsParsed() listeners.
   base::CallbackList<AllRulesetsParsedCallbackSignature> callback_list_;
 
+  base::OnceCallback<void()> all_rulesets_loaded_callback_for_testing_;
+
   // Per-profile helpers.
   std::unique_ptr<AlternativeBrowserDriver> driver_;
   std::unique_ptr<BrowserSwitcherSitelist> sitelist_;

chrome/browser/browser_switcher/browser_switcher_service_win.cc

@@ -27,6 +27,8 @@
 #include "chrome/browser/browser_switcher/browser_switcher_sitelist.h"
 #include "chrome/browser/browser_switcher/ieem_sitelist_parser.h"
 #include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_task_traits.h"
+#include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_registry.h"
 
 namespace browser_switcher {
@@ -136,9 +138,7 @@ BrowserSwitcherServiceWin::BrowserSwitcherServiceWin(
       cache_dir_for_testing_(std::move(cache_dir_for_testing)),
       sequenced_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
           {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
-           base::TaskShutdownBehavior::BLOCK_SHUTDOWN})) {
-  UpdateAllCacheFiles();
-}
+           base::TaskShutdownBehavior::BLOCK_SHUTDOWN})) {}
 
 BrowserSwitcherServiceWin::~BrowserSwitcherServiceWin() = default;
 
@@ -166,14 +166,16 @@ std::vector<RulesetSource> BrowserSwitcherServiceWin::GetRulesetSources() {
   return sources;
 }
 
+void BrowserSwitcherServiceWin::Init() {
+  BrowserSwitcherService::Init();
+  UpdateAllCacheFiles();
+}
+
 void BrowserSwitcherServiceWin::LoadRulesFromPrefs() {
   BrowserSwitcherService::LoadRulesFromPrefs();
   if (prefs().UseIeSitelist())
     sitelist()->SetIeemSitelist(
         ParsedXml(prefs().GetCachedIeemSitelist(), base::nullopt));
-  if (!prefs().IsEnabled())
-    return;
-  SavePrefsToFile();
 }
 
 base::FilePath BrowserSwitcherServiceWin::GetCacheDir() {
@@ -232,25 +234,51 @@ void BrowserSwitcherServiceWin::OnIeemSitelistParsed(ParsedXml xml) {
   }
 }
 
-void BrowserSwitcherServiceWin::SavePrefsToFile() {
-  DCHECK(prefs().IsEnabled());
+void BrowserSwitcherServiceWin::CacheFileUpdated() {
+  if (cache_file_updated_callback_for_testing_)
+    std::move(cache_file_updated_callback_for_testing_).Run();
+}
+
+void BrowserSwitcherServiceWin::SitelistCacheFileUpdated() {
+  if (sitelist_cache_file_updated_callback_for_testing_)
+    std::move(sitelist_cache_file_updated_callback_for_testing_).Run();
+}
+
+void BrowserSwitcherServiceWin::OnCacheFileUpdatedForTesting(
+    base::OnceClosure cb) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  cache_file_updated_callback_for_testing_ = std::move(cb);
+}
+
+void BrowserSwitcherServiceWin::OnSitelistCacheFileUpdatedForTesting(
+    base::OnceClosure cb) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  sitelist_cache_file_updated_callback_for_testing_ = std::move(cb);
+}
+
+void BrowserSwitcherServiceWin::DeletePrefsFile() {
   base::FilePath path = GetCacheDir();
   if (path.empty())
     return;
   path = path.AppendASCII("cache.dat");
-  sequenced_task_runner_->PostTask(
-      FROM_HERE,
-      base::BindOnce(&SaveDataToFile, SerializeCacheFile(prefs(), sitelist()),
-                     std::move(path)));
+  sequenced_task_runner_->PostTaskAndReply(
+      FROM_HERE, base::BindOnce(&RemoveFile, std::move(path)),
+      base::BindOnce(&BrowserSwitcherServiceWin::CacheFileUpdated,
+                     base::Unretained(this)));
 }
 
-void BrowserSwitcherServiceWin::DeletePrefsFile() {
+void BrowserSwitcherServiceWin::SavePrefsToFile() {
+  DCHECK(prefs().IsEnabled());
   base::FilePath path = GetCacheDir();
   if (path.empty())
     return;
   path = path.AppendASCII("cache.dat");
-  sequenced_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&RemoveFile, std::move(path)));
+  sequenced_task_runner_->PostTaskAndReply(
+      FROM_HERE,
+      base::BindOnce(&SaveDataToFile, SerializeCacheFile(prefs(), sitelist()),
+                     std::move(path)),
+      base::BindOnce(&BrowserSwitcherServiceWin::CacheFileUpdated,
+                     base::Unretained(this)));
 }
 
 void BrowserSwitcherServiceWin::DeleteSitelistCacheFile() {
@@ -258,8 +286,10 @@ void BrowserSwitcherServiceWin::DeleteSitelistCacheFile() {
   if (path.empty())
     return;
   path = path.AppendASCII("sitelistcache.dat");
-  sequenced_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&RemoveFile, std::move(path)));
+  sequenced_task_runner_->PostTaskAndReply(
+      FROM_HERE, base::BindOnce(&RemoveFile, std::move(path)),
+      base::BindOnce(&BrowserSwitcherServiceWin::SitelistCacheFileUpdated,
+                     base::Unretained(this)));
 }
 
 void BrowserSwitcherServiceWin::UpdateAllCacheFiles() {

chrome/browser/browser_switcher/browser_switcher_service_win.h

@@ -22,6 +22,8 @@ class BrowserSwitcherServiceWin : public BrowserSwitcherService {
       base::FilePath cache_dir_for_testing = base::FilePath());
   ~BrowserSwitcherServiceWin() override;
 
+  void Init() override;
+
   static void SetIeemSitelistUrlForTesting(const std::string& url);
 
   // BrowserSwitcherService:
@@ -29,6 +31,9 @@ class BrowserSwitcherServiceWin : public BrowserSwitcherService {
 
   void LoadRulesFromPrefs() override;
 
+  void OnCacheFileUpdatedForTesting(base::OnceClosure cb);
+  void OnSitelistCacheFileUpdatedForTesting(base::OnceClosure cb);
+
  protected:
   // BrowserSwitcherService:
   void OnAllRulesetsParsed() override;
@@ -59,11 +64,16 @@ class BrowserSwitcherServiceWin : public BrowserSwitcherService {
   // extension, or from a previous Chrome version. Called during initialization.
   void DeleteSitelistCacheFile();
 
+  void CacheFileUpdated();
+  void SitelistCacheFileUpdated();
+
   // Updates or cleans up cache.dat and sitelistcache.dat, based on whether
   // BrowserSwitcher is enabled or disabled.
   void UpdateAllCacheFiles();
 
   base::FilePath cache_dir_for_testing_;
+  base::OnceClosure cache_file_updated_callback_for_testing_;
+  base::OnceClosure sitelist_cache_file_updated_callback_for_testing_;
 
   scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_;