Fix cases where RunLoop is created without a MessageLoop.

content/browser/loader/async_revalidation_manager_browsertest.cc

 // Copyright 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 <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 30 matching lines @@
 class AsyncRevalidationManagerBrowserTest : public ContentBrowserTest {
  protected:
   AsyncRevalidationManagerBrowserTest() {}
   ~AsyncRevalidationManagerBrowserTest() override {}
 
   void SetUp() override {
     scoped_feature_list_.InitAndEnableFeature(features::kStaleWhileRevalidate);
     ContentBrowserTest::SetUp();
   }
 
-  base::RunLoop* run_loop() { return &run_loop_; }
+  void SetUpOnMainThread() override {
+    ContentBrowserTest::SetUpOnMainThread();
+    run_loop_.reset(new base::RunLoop);
+  }
+
+  base::RunLoop* run_loop() {
+    DCHECK(run_loop_);
+    return run_loop_.get();
+  }
+
   int requests_counted() const { return requests_counted_; }
 
   // This method lacks diagnostics for the failure case because TitleWatcher
   // will just wait until the test times out if |expected_title| does not
   // appear.
   bool TitleBecomes(const GURL& url, const std::string& expected_title) {
     base::string16 expected_title16(base::ASCIIToUTF16(expected_title));
     TitleWatcher title_watcher(shell()->web_contents(), expected_title16);
     NavigateToURL(shell(), url);
     return title_watcher.WaitAndGetTitle() == expected_title16;
@@ skipping 23 matching lines @@
 
     std::unique_ptr<BasicHttpResponse> http_response(
         StaleWhileRevalidateHeaders());
     http_response->set_content(
         base::StringPrintf("<title>Version %d</title>", version));
 
     // The second time this handler is run is the async revalidation. Tests can
     // use this for synchronisation.
     if (version == 2) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                              run_loop_.QuitClosure());
+                              run_loop()->QuitClosure());
     }
     return std::move(http_response);
   }
 
   // A request handler which increases a cookie value on every request.
   std::unique_ptr<HttpResponse> CookieRequestHandler(
       const HttpRequest& request) {
     static const char kHtml[] =
         "<script>\n"
         "var intervalId;\n"
@@ skipping 29 matching lines @@
     http_response->AddCustomHeader("Cache-Control",
                                    "max-age=0, stale-while-revalidate=86400");
     // A validator is needed for revalidations, and hence
     // stale-while-revalidate, to work.
     std::string etag = base::StringPrintf(
         "\"AsyncRevalidationManagerBrowserTest%d\"", requests_counted_);
     http_response->AddCustomHeader("ETag", etag);
     return http_response;
   }
 
-  base::RunLoop run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
   int requests_counted_ = 0;
   base::test::ScopedFeatureList scoped_feature_list_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncRevalidationManagerBrowserTest);
 };
 
 // Verify that the "Cache-Control: stale-while-revalidate" directive correctly
 // triggers an async revalidation.
 IN_PROC_BROWSER_TEST_F(AsyncRevalidationManagerBrowserTest,
                        StaleWhileRevalidateIsApplied) {
@@ skipping 76 matching lines @@
   NavigateToURL(shell(), GURL("about:blank"));
 
   // The page will load from the cache, then when the async revalidation
   // completes the cookie will update.
   EXPECT_TRUE(TitleBecomes(url, "PASS"));
 }
 
 }  // namespace
 
 }  // namespace content