Prevent tabs sync during browser shutdown.

chrome/browser/sync/test/integration/sessions_helper.cc

 // Copyright (c) 2012 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 "chrome/browser/sync/test/integration/sessions_helper.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <utility>
@@ skipping 97 matching lines @@
   Browser* browser = test()->GetBrowser(index);
   for (std::vector<GURL>::const_iterator it = urls.begin();
        it != urls.end(); ++it) {
     DVLOG(1) << "Opening tab: " << it->spec() << " using browser " << index
              << ".";
     chrome::ShowSingletonTab(browser, *it);
   }
   return WaitForTabsToLoad(index, urls);
 }
 
+bool CloseTabAtIndex(int index, int tab_index, const GURL& url) {
+  auto* tab_strip = test()->GetBrowser(index)->tab_strip_model();
+  tab_strip->CloseWebContentsAt(tab_index, TabStripModel::CLOSE_NONE);
+
+  return WaitForTabsToClose(index, {url});
+}
+
 void MoveTab(int from_index, int to_index, int tab_index) {
   content::WebContents* detached_contents =
       test()
           ->GetBrowser(from_index)
           ->tab_strip_model()
           ->DetachWebContentsAt(tab_index);
 
   TabStripModel* target_strip = test()->GetBrowser(to_index)->tab_strip_model();
   target_strip->InsertWebContentsAt(target_strip->count(), detached_contents,
                                     TabStripModel::ADD_ACTIVE);
@@ skipping 46 matching lines @@
   }
 
   void OnFaviconsChanged(const std::set<GURL>& /* page_urls */,
                          const GURL& /* icon_url */) override {
     // Unwind to ensure SessionsSyncManager has processed the event.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TabEventHandler::QuitLoop, weak_factory_.GetWeakPtr()));
   }
 
+  void SetAllBrowsersClosing(bool /*browsers_closing*/) override {}
+
  private:
   void QuitLoop() { base::MessageLoop::current()->QuitWhenIdle(); }
 
   base::WeakPtrFactory<TabEventHandler> weak_factory_;
 };
 
-}  // namespace
-
-bool WaitForTabsToLoad(int index, const std::vector<GURL>& urls) {
+bool WaitForTabsToLoadOrClose(int index,
+                              const std::vector<GURL>& urls,
+                              bool wait_load) {
   DVLOG(1) << "Waiting for session to propagate to associator.";
   base::TimeTicks start_time = base::TimeTicks::Now();
   base::TimeTicks end_time = start_time + TestTimeouts::action_max_timeout();
   bool found;
-  for (std::vector<GURL>::const_iterator it = urls.begin();
-       it != urls.end(); ++it) {
-    found = false;
-    while (!found) {
+  for (std::vector<GURL>::const_iterator it = urls.begin(); it != urls.end();
+       ++it) {
+    found = !wait_load;
+    while (found != wait_load) {
       found = ModelAssociatorHasTabWithUrl(index, *it);
       if (base::TimeTicks::Now() >= end_time) {
         LOG(ERROR) << "Failed to find all tabs after "
                    << TestTimeouts::action_max_timeout().InSecondsF()
                    << " seconds.";
         return false;
       }
-      if (!found) {
+      if (found != wait_load) {
         TabEventHandler handler;
         sync_sessions::NotificationServiceSessionsRouter router(
             test()->GetProfile(index),
             ProfileSyncServiceFactory::GetInstance()
                 ->GetForProfile(test()->GetProfile(index))
                 ->GetSyncClient()
                 ->GetSyncSessionsClient(),
             syncer::SyncableService::StartSyncFlare());
         router.StartRoutingTo(&handler);
         content::RunMessageLoop();
       }
     }
   }
   return true;
 }
 
+}  // namespace
+
+bool WaitForTabsToLoad(int index, const std::vector<GURL>& urls) {
+  return WaitForTabsToLoadOrClose(index, urls, true);
+}
+
+bool WaitForTabsToClose(int index, const std::vector<GURL>& urls) {
+  return WaitForTabsToLoadOrClose(index, urls, false);
+}
+
 bool GetLocalWindows(int index, ScopedWindowMap* local_windows) {
   // The local session provided by GetLocalSession is owned, and has lifetime
   // controlled, by the model associator, so we must make our own copy.
   const sync_sessions::SyncedSession* local_session;
   if (!GetLocalSession(index, &local_session)) {
     return false;
   }
   for (auto w = local_session->windows.begin();
        w != local_session->windows.end(); ++w) {
     const sessions::SessionWindow& window = *(w->second);
@@ skipping 201 matching lines @@
       index_(index),
       windows_(windows) {}
 
 bool ForeignSessionsMatchChecker::IsExitConditionSatisfied() {
   return sessions_helper::CheckForeignSessionsAgainst(index_, windows_);
 }
 
 std::string ForeignSessionsMatchChecker::GetDebugMessage() const {
   return "Waiting for matching foreign sessions";
 }