Prerender: remove possible race in browser tests to improve flakiness.

chrome/browser/prerender/prerender_test_utils.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 "chrome/browser/prerender/prerender_test_utils.h"
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/loader/chrome_resource_dispatcher_host_delegate.h"
 #include "chrome/browser/prerender/prerender_manager.h"
@@ skipping 339 matching lines @@
     : waiter_(waiter) {}
 
 DestructionWaiter::DestructionMarker::~DestructionMarker() {}
 
 void DestructionWaiter::DestructionMarker::OnPrerenderStop(
     PrerenderContents* contents) {
   waiter_->MarkDestruction(contents->final_status());
 }
 
 TestPrerender::TestPrerender()
-    : contents_(nullptr), number_of_loads_(0), expected_number_of_loads_(0) {}
+    : contents_(nullptr),
+      number_of_loads_(0),
+      expected_number_of_loads_(0),
+      started_(false),
+      stopped_(false) {}
 
 TestPrerender::~TestPrerender() {
   if (contents_)
     contents_->RemoveObserver(this);
 }
 
+void TestPrerender::WaitForCreate() {
+  if (contents_)
+    return;
+  create_loop_.Run();
+}
+
+void TestPrerender::WaitForStart() {
+  if (started_)
+    return;
+  start_loop_.Run();
+}
+
+void TestPrerender::WaitForStop() {
+  if (stopped_)
+    return;
+  stop_loop_.Run();
+}
+
 void TestPrerender::WaitForLoads(int expected_number_of_loads) {
   DCHECK(!load_waiter_);
   DCHECK(!expected_number_of_loads_);
   if (number_of_loads_ < expected_number_of_loads) {
     load_waiter_.reset(new base::RunLoop);
     expected_number_of_loads_ = expected_number_of_loads;
     load_waiter_->Run();
     load_waiter_.reset();
     expected_number_of_loads_ = 0;
   }
   EXPECT_LE(expected_number_of_loads, number_of_loads_);
 }
 
 void TestPrerender::OnPrerenderCreated(TestPrerenderContents* contents) {
   DCHECK(!contents_);
   contents_ = contents;
   contents_->AddObserver(this);
   create_loop_.Quit();
 }
 
 void TestPrerender::OnPrerenderStart(PrerenderContents* contents) {
+  started_ = true;
   start_loop_.Quit();
 }
 
 void TestPrerender::OnPrerenderStopLoading(PrerenderContents* contents) {
   number_of_loads_++;
   if (load_waiter_ && number_of_loads_ >= expected_number_of_loads_)
     load_waiter_->Quit();
 }
 
 void TestPrerender::OnPrerenderStop(PrerenderContents* contents) {
   DCHECK(contents_);
   contents_ = nullptr;
+  stopped_ = true;
   stop_loop_.Quit();
   // If there is a WaitForLoads call and it has yet to see the expected number
   // of loads, stop the loop so the test fails instead of timing out.
   if (load_waiter_)
     load_waiter_->Quit();
 }
 
 TestPrerenderContentsFactory::TestPrerenderContentsFactory() {}
 
 TestPrerenderContentsFactory::~TestPrerenderContentsFactory() {
@@ skipping 237 matching lines @@
 void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, net::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
                file, content::BrowserThread::GetBlockingPool()));
 }
 
 }  // namespace test_utils
 
 }  // namespace prerender