Do not run a nested loop in content::DeferredQuitRunLoop.

chrome/browser/sync/test/integration/bookmarks_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/bookmarks_helper.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <stack>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
@@ skipping 22 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "ui/gfx/image/image_skia.h"
 
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
 
 namespace {
 
-// History task which runs all pending tasks on the history thread and
-// signals when the tasks have completed.
-class HistoryEmptyTask : public history::HistoryDBTask {
+// History task which signals an event.
+class SignalEventTask : public history::HistoryDBTask {
  public:
-  explicit HistoryEmptyTask(base::WaitableEvent* done) : done_(done) {}
+  explicit SignalEventTask(base::WaitableEvent* done) : done_(done) {}
 
   bool RunOnDBThread(history::HistoryBackend* backend,
                      history::HistoryDatabase* db) override {
-    content::RunAllPendingInMessageLoop();
     done_->Signal();
     return true;
   }
 
   void DoneRunOnMainThread() override {}
 
  private:
   base::WaitableEvent* done_;
 };
 
@@ skipping 228 matching lines @@
     profiles_which_need_to_wait.push_back(
         sync_datatype_helper::test()->GetProfile(i));
 
   for (size_t i = 0; i < profiles_which_need_to_wait.size(); ++i) {
     Profile* profile = profiles_which_need_to_wait[i];
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfileWithoutCreating(profile);
     base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                              base::WaitableEvent::InitialState::NOT_SIGNALED);
     base::CancelableTaskTracker task_tracker;
-    history_service->ScheduleDBTask(
-        std::unique_ptr<history::HistoryDBTask>(new HistoryEmptyTask(&done)),
-        &task_tracker);
+    // Post a task that signals |done|. Since tasks run in posting order, all
+    // previously posted tasks have run when |done| is signaled.
+    history_service->ScheduleDBTask(base::MakeUnique<SignalEventTask>(&done),
+                                    &task_tracker);
     done.Wait();
   }
   // Wait such that any notifications broadcast from one of the history threads
   // to the UI thread are processed.
   content::RunAllPendingInMessageLoop();
 }
 
 // Checks if the favicon in |node_a| from |model_a| matches that of |node_b|
 // from |model_b|. Returns true if they match.
 bool FaviconsMatch(BookmarkModel* model_a,
@@ skipping 616 matching lines @@
 }  // namespace
 
 BookmarksUrlChecker::BookmarksUrlChecker(int profile,
                                          const GURL& url,
                                          int expected_count)
     : AwaitMatchStatusChangeChecker(base::Bind(BookmarkCountsByUrlMatch,
                                                profile,
                                                base::ConstRef(url),
                                                expected_count),
                                     "Bookmark URL counts match.") {}