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 50 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),
+        quit_waiting_callback_(),

[Randy Smith (Not in Mondays), 2015/10/19 19:37:02]

I think member variables normally are default constructed if you don't mention
them in the constructor list, so I think you can just remove this line.

[Łukasz Anforowicz, 2015/10/19 22:04:39]

Done.

In the original patchset/snapshot, I left this line to indicate to the reader,
that we didn't simply forget to initialize this member (i.e. that we
really/explicitly are happy with the default initialization).  OTOH, I guess
consistency triumphs this (and I think elsewhere in Chromium default
initialization is not explicitly mentioned on initializer lists).

+        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()->Quit();
+    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) {
-  }
+        quit_waiting_callback_(),

[Randy Smith (Not in Mondays), 2015/10/19 19:37:01]

Ditto (can remove line).

[Łukasz Anforowicz, 2015/10/19 22:04:39]

Done.

+        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()->Quit();
+    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) {
+      : quit_waiting_callback_(), manager_(manager) {

[Randy Smith (Not in Mondays), 2015/10/19 19:37:02]

Ditto.

[Łukasz Anforowicz, 2015/10/19 22:04:39]

Done.

     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()->Quit();
+    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()->Quit();
+    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 621 matching lines @@
   ASSERT_TRUE(base::ReadFileToString(full_file_name, &main_contents));
   EXPECT_THAT(main_contents,
               HasSubstr("<iframe src=\"./iframes_files/a.html\"></iframe>"));
   EXPECT_THAT(main_contents,
               HasSubstr("<iframe src=\"./iframes_files/b.html\"></iframe>"));
   EXPECT_THAT(main_contents,
               HasSubstr("<img src=\"./iframes_files/1.png\">"));
 }
 
 }  // namespace