Replace RunLoop with WaitableEvent in ConditionalCacheDeletionHelperBrowserTest

chrome/browser/browsing_data/conditional_cache_deletion_helper_browsertest.cc

 // Copyright (c) 2015 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 <algorithm>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/browsing_data/content/conditional_cache_deletion_helper.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
@@ skipping 20 matching lines @@
 class ConditionalCacheDeletionHelperBrowserTest : public InProcessBrowserTest {
  public:
   // Initialization ------------------------------------------------------------
 
   void SetUpOnMainThread() override {
     // Prepare the commonly used callbacks.
     done_callback_ = base::Bind(
         &ConditionalCacheDeletionHelperBrowserTest::DoneCallback,
         base::Unretained(this));
 
+    // UI and IO thread synchronization.
+    waitable_event_ = base::MakeUnique<base::WaitableEvent>(
+        base::WaitableEvent::ResetPolicy::AUTOMATIC,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
+
     // Get the storage partition.
     partition_ = content::BrowserContext::GetDefaultStoragePartition(
         browser()->profile());
 
     // Get the cache backends.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ConditionalCacheDeletionHelperBrowserTest::SetUpOnIOThread,
                    base::Unretained(this)));
     WaitForTasksOnIOThread();
@@ skipping 22 matching lines @@
 
   void TearDownOnIOThread() {
     iterator_.reset();
     DoneCallback(net::OK);
   }
 
   // Waiting for tasks to be done on IO thread. --------------------------------
 
   void WaitForTasksOnIOThread() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    io_thread_loop_.reset(new base::RunLoop());
-    io_thread_loop_->Run();
+    waitable_event_->Wait();
   }
 
   void SetNumberOfWaitedTasks(int count) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     remaining_tasks_ = count;
   }
 
   void WaitForCompletion(int value) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (value >= 0) {
       // We got the result immediately.
       DoneCallback(value);
     } else if (value == net::ERR_IO_PENDING) {
       // We need to wait for the callback.
     } else {
       // An error has occurred.
       NOTREACHED();
     }
   }
 
   void DoneCallback(int value) {
     DCHECK_GE(value, 0);  // Negative values represent an error.
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (--remaining_tasks_ > 0)
       return;
 
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&base::RunLoop::Quit,
-                   base::Unretained(io_thread_loop_.get())));
+    waitable_event_->Signal();
   }
 
   // Cache operation shorthands. -----------------------------------------------
 
   void CreateCacheEntries(const std::set<std::string>& keys) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     entries_.resize(keys.size());
     SetNumberOfWaitedTasks(keys.size());
 
@@ skipping 50 matching lines @@
 
  private:
   content::StoragePartition* partition_;
   disk_cache::Backend* backend_ = nullptr;
   std::unique_ptr<disk_cache::Backend::Iterator> iterator_;
   disk_cache::Entry* current_entry_;
   std::vector<disk_cache::Entry*> entries_;
 
   base::Callback<void(int)> done_callback_;
 
-  std::unique_ptr<base::RunLoop> io_thread_loop_;
+  std::unique_ptr<base::WaitableEvent> waitable_event_;
   int remaining_tasks_;
 
   std::vector<std::string> remaining_keys_;
 };
 
 // Tests that ConditionalCacheDeletionHelper only deletes those cache entries
 // that match the condition.
 IN_PROC_BROWSER_TEST_F(ConditionalCacheDeletionHelperBrowserTest, Condition) {
   // Create 5 entries.
   std::set<std::string> keys;
@@ skipping 99 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ConditionalCacheDeletionHelperBrowserTest::GetRemainingKeys,
                  base::Unretained(this)));
   WaitForTasksOnIOThread();
 
   keys.insert(newer_keys.begin(), newer_keys.end());
   keys.erase("https://example.com/foo/bar/icon2.png");
   keys.erase("https://example.com/foo/bar/icon3.png");
   CompareRemainingKeys(keys);
 }