Replace ExtensionInstallChecker with generic PreloadCheckGroup

extensions/browser/preload_check_test_util.cc

 // Copyright 2017 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 "extensions/browser/preload_check_test_util.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 18 matching lines @@
 }
 
 void PreloadCheckRunner::Run(PreloadCheck* check) {
   check->Start(GetCallback());
 }
 
 void PreloadCheckRunner::RunUntilComplete(PreloadCheck* check) {
   Run(check);
   ASSERT_FALSE(called_);
 
-  run_loop_ = base::MakeUnique<base::RunLoop>();
-  run_loop_->Run();
+  WaitForComplete();

[Devlin, 2017/04/06 02:03:53]

Just a note - currently this is incompatible with sync checks.  We could make it
sync/async agnostic if we always instantiated the run loop before the call to
Run() and always called Quit() in OnCheckComplete.  RunLoop is designed to be
able to accept Quit() being called before Run() (in which case the loop quits
immediately).

[michaelpg, 2017/04/06 22:31:16]

RunUntilComplete requires the check to be async, thus ASSERT_FALSE(called_).

But, that's kind of subtle. I'll use your suggestion; a caller can still decide
when to assert the check *doesn't* start.

   ASSERT_TRUE(called_);
 }
 
 PreloadCheck::ResultCallback PreloadCheckRunner::GetCallback() {
   return base::Bind(&PreloadCheckRunner::OnCheckComplete,
                     base::Unretained(this));
 }
 
 void PreloadCheckRunner::WaitForIdle() {
   run_loop_ = base::MakeUnique<base::RunLoop>();
   run_loop_->RunUntilIdle();
 }
 
+void PreloadCheckRunner::WaitForComplete() {
+  run_loop_ = base::MakeUnique<base::RunLoop>();
+  run_loop_->Run();
+}
+
 // PreloadCheckStub:
-PreloadCheckStub::PreloadCheckStub()
-    : PreloadCheck(nullptr), is_async_(false), weak_ptr_factory_(this) {}
+PreloadCheckStub::PreloadCheckStub(const Errors& errors)
+    : PreloadCheck(nullptr), errors_(errors), weak_ptr_factory_(this) {}
 
 PreloadCheckStub::~PreloadCheckStub() {}
 
-void PreloadCheckStub::AddError(Error error) {
-  errors_.insert(error);
-}
-
 void PreloadCheckStub::Start(ResultCallback callback) {
   DCHECK(!callback.is_null());
+  started_ = true;
   if (is_async_) {
     // TODO(michaelpg): Bind the callback directly and remove RunCallback
     // once crbug.com/704027 is addressed.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&PreloadCheckStub::RunCallback,
                    weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
   } else {
     std::move(callback).Run(errors_);
   }
 }
 
 void PreloadCheckStub::RunCallback(ResultCallback callback) {
   std::move(callback).Run(errors_);
 }
 
-base::string16 PreloadCheckStub::GetErrorMessage() const {
-  return message_;
-}
-
 }  // namespace extensions