Using RunLoop rather than the deprecated, older loop running methods.

chrome/browser/download/save_page_browsertest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 51 matching lines @@
 
 // Waits for an item record in the downloads database to match |filter|. See
 // DownloadStoredProperly() below for an example filter.
 class DownloadPersistedObserver : public DownloadHistory::Observer {
  public:
   typedef base::Callback<bool(
       DownloadItem* item,
       const history::DownloadRow&)> PersistedFilter;
 
   DownloadPersistedObserver(Profile* profile, const PersistedFilter& filter)
-    : profile_(profile),
-      filter_(filter),
-      waiting_(false),
-      persisted_(false) {
+      : profile_(profile),
+        filter_(filter),
+        persisted_(false) {
     DownloadServiceFactory::GetForBrowserContext(profile_)->
       GetDownloadHistory()->AddObserver(this);
   }
 
   ~DownloadPersistedObserver() override {
     DownloadService* service = DownloadServiceFactory::GetForBrowserContext(
         profile_);
     if (service && service->GetDownloadHistory())
       service->GetDownloadHistory()->RemoveObserver(this);
   }
 
   bool WaitForPersisted() {
     if (persisted_)
       return true;
-    waiting_ = true;
-    content::RunMessageLoop();
-    waiting_ = false;
+    base::RunLoop run_loop;
+    quit_waiting_callback_ = run_loop.QuitClosure();
+    run_loop.Run();
+    quit_waiting_callback_ = base::Closure();
     return persisted_;
   }
 
   void OnDownloadStored(DownloadItem* item,
                         const history::DownloadRow& info) override {
     persisted_ = persisted_ || filter_.Run(item, info);
-    if (persisted_ && waiting_)
-      base::MessageLoopForUI::current()->QuitWhenIdle();
+    if (persisted_ && !quit_waiting_callback_.is_null())
+      quit_waiting_callback_.Run();
   }
 
  private:
   Profile* profile_;
   PersistedFilter filter_;
-  bool waiting_;
+  base::Closure quit_waiting_callback_;
   bool persisted_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadPersistedObserver);
 };
 
 // Waits for an item record to be removed from the downloads database.
 class DownloadRemovedObserver : public DownloadPersistedObserver {
  public:
   DownloadRemovedObserver(Profile* profile, int32 download_id)
       : DownloadPersistedObserver(profile, PersistedFilter()),
         removed_(false),
-        waiting_(false),
-        download_id_(download_id) {
-  }
+        download_id_(download_id) {}
   ~DownloadRemovedObserver() override {}
 
   bool WaitForRemoved() {
     if (removed_)
       return true;
-    waiting_ = true;
-    content::RunMessageLoop();
-    waiting_ = false;
+    base::RunLoop run_loop;
+    quit_waiting_callback_ = run_loop.QuitClosure();
+    run_loop.Run();
+    quit_waiting_callback_ = base::Closure();
     return removed_;
   }
 
   void OnDownloadStored(DownloadItem* item,
                         const history::DownloadRow& info) override {}
 
   void OnDownloadsRemoved(const DownloadHistory::IdSet& ids) override {
     removed_ = ids.find(download_id_) != ids.end();
-    if (removed_ && waiting_)
-      base::MessageLoopForUI::current()->QuitWhenIdle();
+    if (removed_ && !quit_waiting_callback_.is_null())
+      quit_waiting_callback_.Run();
   }
 
  private:
   bool removed_;
-  bool waiting_;
+  base::Closure quit_waiting_callback_;
   int32 download_id_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadRemovedObserver);
 };
 
 bool DownloadStoredProperly(
     const GURL& expected_url,
     const base::FilePath& expected_path,
     int64 num_files,
     history::DownloadState expected_state,
@@ skipping 31 matching lines @@
 }
 
 const base::FilePath::CharType kTestDir[] = FILE_PATH_LITERAL("save_page");
 
 static const char kAppendedExtension[] = ".html";
 
 // Loosely based on logic in DownloadTestObserver.
 class DownloadItemCreatedObserver : public DownloadManager::Observer {
  public:
   explicit DownloadItemCreatedObserver(DownloadManager* manager)
-      : waiting_(false), manager_(manager) {
+      : manager_(manager) {
     manager->AddObserver(this);
   }
 
   ~DownloadItemCreatedObserver() override {
     if (manager_)
       manager_->RemoveObserver(this);
   }
 
   // Wait for the first download item created after object creation.
   // Note that this class provides no protection against the download
   // being destroyed between creation and return of WaitForNewDownloadItem();
   // the caller must guarantee that in some other fashion.
   void WaitForDownloadItem(std::vector<DownloadItem*>* items_seen) {
     if (!manager_) {
       // The manager went away before we were asked to wait; return
       // what we have, even if it's null.
       *items_seen = items_seen_;
       return;
     }
 
     if (items_seen_.empty()) {
-      waiting_ = true;
-      content::RunMessageLoop();
-      waiting_ = false;
+      base::RunLoop run_loop;
+      quit_waiting_callback_ = run_loop.QuitClosure();
+      run_loop.Run();
+      quit_waiting_callback_ = base::Closure();
     }
 
     *items_seen = items_seen_;
     return;
   }
 
  private:
   // DownloadManager::Observer
   void OnDownloadCreated(DownloadManager* manager,
                          DownloadItem* item) override {
     DCHECK_EQ(manager, manager_);
     items_seen_.push_back(item);
 
-    if (waiting_)
-      base::MessageLoopForUI::current()->QuitWhenIdle();
+    if (!quit_waiting_callback_.is_null())
+      quit_waiting_callback_.Run();
   }
 
   void ManagerGoingDown(DownloadManager* manager) override {
     manager_->RemoveObserver(this);
     manager_ = NULL;
-    if (waiting_)
-      base::MessageLoopForUI::current()->QuitWhenIdle();
+    if (!quit_waiting_callback_.is_null())
+      quit_waiting_callback_.Run();
   }
 
-  bool waiting_;
+  base::Closure quit_waiting_callback_;
   DownloadManager* manager_;
   std::vector<DownloadItem*> items_seen_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemCreatedObserver);
 };
 
 class SavePackageFinishedObserver : public content::DownloadManager::Observer {
  public:
   SavePackageFinishedObserver(content::DownloadManager* manager,
                               const base::Closure& callback)
@@ skipping 674 matching lines @@
     pos = mhtml.find("Content-Type: image/png", pos);
     if (pos == std::string::npos)
       break;
     count++;
     pos++;
   }
   EXPECT_EQ(1, count) << "Verify number of image/png parts in the mhtml output";
 }
 
 }  // namespace