Use ScopedTaskEnvironment instead of MessageLoopForUI in components tests.

components/precache/core/precache_fetcher_unittest.cc

 // Copyright 2013 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 "components/precache/core/precache_fetcher.h"
 
 #include <stdint.h>
 
 #include <cstring>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/precache/core/precache_database.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/precache.pb.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_status_code.h"
@@ skipping 164 matching lines @@
    private:
     std::string body_;
     F modifier_;
     net::FakeURLFetcher** fetcher_;
   };
 };
 
 class PrecacheFetcherFetcherTest : public testing::Test {
  public:
   PrecacheFetcherFetcherTest()
-      : request_context_(new net::TestURLRequestContextGetter(
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        request_context_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())),
         scoped_url_fetcher_factory_(&factory_),
         callback_(base::Bind(&PrecacheFetcherFetcherTest::Callback,
                              base::Unretained(this))) {}
 
   MOCK_METHOD1(Callback, void(const PrecacheFetcher::Fetcher&));
 
  protected:
-  base::MessageLoopForUI loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   MockURLFetcherFactory factory_;
   net::ScopedURLFetcherFactory scoped_url_fetcher_factory_;
   base::Callback<void(const PrecacheFetcher::Fetcher&)> callback_;
 };
 
 void CacheMiss(net::FakeURLFetcher* fetcher) {
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                             net::ERR_CACHE_MISS));
 }
@@ skipping 185 matching lines @@
       request_context_.get(), url, url.host(), callback_,
       true /* is_resource_request */, 99 /* max_bytes */,
       false /* revalidation_only */);
 
   base::RunLoop().RunUntilIdle();
 }
 
 class PrecacheFetcherTest : public testing::Test {
  public:
   PrecacheFetcherTest()
-      : task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        task_runner_(base::ThreadTaskRunnerHandle::Get()),
         request_context_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())),
         factory_(NULL,
                  base::Bind(&TestURLFetcherCallback::CreateURLFetcher,
                             base::Unretained(&url_callback_))),
         expected_total_response_bytes_(0),
         parallel_fetches_beyond_capacity_(false) {}
 
   void UpdatePrecacheReferrerHost(const std::string& hostname,
                                   int64_t manifest_id) {
@@ skipping 36 matching lines @@
   void CheckUntilParallelFetchesBeyondCapacity(
       const PrecacheFetcher* precache_fetcher) {
     if (!precache_fetcher->pool_.IsAvailable() &&
         (!precache_fetcher->top_hosts_to_fetch_.empty() ||
          !precache_fetcher->resources_to_fetch_.empty())) {
       parallel_fetches_beyond_capacity_ = true;
       return;
     }
 
     // Check again after allowing the message loop to process some messages.
-    loop_.task_runner()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             &PrecacheFetcherTest::CheckUntilParallelFetchesBeyondCapacity,
             base::Unretained(this), precache_fetcher));
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner>& task_runner() const {
     return task_runner_;
   }
 
   // To allow friend access.
   void Flush() { precache_database_.Flush(); }
 
   // Must be declared first so that it is destroyed last.
-  base::MessageLoopForUI loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   TestURLFetcherCallback url_callback_;
   net::FakeURLFetcherFactory factory_;
   TestPrecacheDelegate precache_delegate_;
   base::ScopedTempDir scoped_temp_dir_;
   PrecacheDatabase precache_database_;
   int expected_total_response_bytes_;
 
   // True if more parallel fetches were attempted beyond the fetcher pool
@@ skipping 1222 matching lines @@
 
     // Run the loop until all tophost manifest fetches are complete, but some
     // resource fetches are pending.
     while (--remaining_tries != 0 &&
            (!precache_fetcher.top_hosts_to_fetch_.empty() ||
             !precache_fetcher.top_hosts_fetching_.empty() ||
             !precache_fetcher.unfinished_work_->has_config_settings() ||
             precache_fetcher.resources_to_fetch_.empty())) {
       LOG(INFO) << "remaining_tries: " << remaining_tries;
       base::RunLoop run_loop;
-      loop_.task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                    run_loop.QuitClosure());
       run_loop.Run();
     }
 
     // Cancel precaching.
     cancelled_work = precache_fetcher.CancelPrecaching();
     EXPECT_TRUE(precache_fetcher.top_hosts_to_fetch_.empty());
     EXPECT_TRUE(precache_fetcher.resources_to_fetch_.empty());
   }
   EXPECT_NE(cancelled_work, nullptr);
   EXPECT_TRUE(cancelled_work->top_host().empty());
@@ skipping 216 matching lines @@
 
     // Run the loop until all tophost manifest fetches are complete, but some
     // resource fetches are pending.
     while (--remaining_tries != 0 &&
            (!precache_fetcher.top_hosts_to_fetch_.empty() ||
             !precache_fetcher.top_hosts_fetching_.empty() ||
             !precache_fetcher.unfinished_work_->has_config_settings() ||
             precache_fetcher.resources_to_fetch_.empty())) {
       LOG(INFO) << "remaining_tries: " << remaining_tries;
       base::RunLoop run_loop;
-      loop_.task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                    run_loop.QuitClosure());
       run_loop.Run();
     }
 
     // Cancel precaching.
     cancelled_work = precache_fetcher.CancelPrecaching();
     EXPECT_TRUE(precache_fetcher.top_hosts_to_fetch_.empty());
     EXPECT_TRUE(precache_fetcher.resources_to_fetch_.empty());
   }
   ASSERT_NE(nullptr, cancelled_work);
   EXPECT_TRUE(cancelled_work->top_host().empty());
@@ skipping 117 matching lines @@
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
   EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectTotalCount("Precache.Fetch.PercentCompleted", 2);
   histogram.ExpectTotalCount("Precache.Fetch.ResponseBytes.Total", 2);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 2);
 }
 
 }  // namespace precache