Move ChromeRequirementsChecker to //extensions as a PreloadCheck

chrome/browser/extensions/extension_install_checker_unittest.cc

 // Copyright 2014 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/extensions/extension_install_checker.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 16 matching lines @@
 // Stubs most of the checks since we are interested in validating the logic in
 // the install checker. This class implements a synchronous version of all
 // checks.
 class ExtensionInstallCheckerForTest : public ExtensionInstallChecker {
  public:
   ExtensionInstallCheckerForTest(int enabled_checks, bool fail_fast)
       : ExtensionInstallChecker(nullptr, nullptr, enabled_checks, fail_fast) {}
 
   ~ExtensionInstallCheckerForTest() override {}
 
-  void set_requirements_error(const std::string& error) {
-    requirements_error_ = error;
-  }
-
   bool is_async() const { return is_async_; }
   void set_is_async(bool is_async) { is_async_ = is_async; }
 
- protected:
-  void MockCheckRequirements() {
-    if (!is_running())
-      return;
-    std::vector<std::string> errors;
-    if (!requirements_error_.empty())
-      errors.push_back(requirements_error_);
-    OnRequirementsCheckDone(errors);
-  }
-
-  void CheckRequirements() override {
-    if (is_async_) {
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&ExtensionInstallCheckerForTest::MockCheckRequirements,
-                     base::Unretained(this)));
-    } else {
-      MockCheckRequirements();
-    }
-  }
-
  private:
   // Whether to run the requirements and blacklist checks asynchronously, as
   // they often do in ExtensionInstallChecker.
   bool is_async_ = false;
-
-  // Dummy error for testing.
-  std::string requirements_error_;
 };
 
 class CheckObserver {
  public:
   CheckObserver() : result_(0), call_count_(0) {}
 
   int result() const { return result_; }
   int call_count() const { return call_count_; }
 
   void OnChecksComplete(int checks_failed) {
@@ skipping 32 matching lines @@
                       std::string message) {
     // The policy check always runs synchronously.
     auto policy_check = base::MakeUnique<PreloadCheckStub>();
     if (error != PreloadCheck::NONE) {
       policy_check->AddError(error);
       policy_check->set_error_message(base::UTF8ToUTF16(message));
     }
     checker->SetPolicyCheckForTesting(std::move(policy_check));
   }
 
+  void SetRequirementsError(ExtensionInstallCheckerForTest* checker,
+                            PreloadCheck::Error error,
+                            const std::string& message) {
+    auto requirements_check = base::MakeUnique<PreloadCheckStub>();
+    requirements_check->set_is_async(checker->is_async());
+    if (error != PreloadCheck::NONE) {
+      requirements_check->AddError(error);
+      requirements_check->set_error_message(base::UTF8ToUTF16(message));
+    }
+    checker->SetRequirementsCheckForTesting(std::move(requirements_check));
+  }
+
  protected:
   void SetAllPass(ExtensionInstallCheckerForTest* checker) {
     SetBlacklistError(checker, PreloadCheck::NONE);
     SetPolicyError(checker, PreloadCheck::NONE, "");
-    checker->set_requirements_error("");
+    SetRequirementsError(checker, PreloadCheck::NONE, "");
   }
 
   void SetAllErrors(ExtensionInstallCheckerForTest* checker) {
     SetBlacklistError(checker, kBlacklistError);
     SetPolicyError(checker, PreloadCheck::DISALLOWED_BY_POLICY,
                    kDummyPolicyError);
-    checker->set_requirements_error(kDummyRequirementsError);
+    SetRequirementsError(checker, PreloadCheck::NPAPI_NOT_SUPPORTED,
+                         kDummyRequirementsError);
   }
 
   void ExpectRequirementsPass(const ExtensionInstallCheckerForTest& checker) {
-    EXPECT_TRUE(checker.requirement_errors().empty());
+    EXPECT_EQ(base::string16(), checker.requirements_error_message());
   }
 
   void ExpectRequirementsError(const char* expected_error,
                                const ExtensionInstallCheckerForTest& checker) {
-    EXPECT_FALSE(checker.requirement_errors().empty());
-    EXPECT_EQ(std::string(expected_error),
-              checker.requirement_errors().front());
+    EXPECT_EQ(base::UTF8ToUTF16(expected_error),
+              checker.requirements_error_message());
   }
 
   void ExpectRequirementsError(const ExtensionInstallCheckerForTest& checker) {
     ExpectRequirementsError(kDummyRequirementsError, checker);
   }
 
   void ExpectBlacklistPass(const ExtensionInstallCheckerForTest& checker) {
     EXPECT_EQ(PreloadCheck::NONE, checker.blacklist_error());
   }
 
   void ExpectBlacklistError(const ExtensionInstallCheckerForTest& checker) {
     EXPECT_EQ(kBlacklistError, checker.blacklist_error());
   }
 
   void ExpectPolicyPass(const ExtensionInstallCheckerForTest& checker) {
     EXPECT_TRUE(checker.policy_error().empty());
   }
 
   void ExpectPolicyError(const char* expected_error,
                          const ExtensionInstallCheckerForTest& checker) {
     EXPECT_FALSE(checker.policy_error().empty());
-    EXPECT_EQ(std::string(expected_error), checker.policy_error());
+    EXPECT_EQ(base::UTF8ToUTF16(expected_error), checker.policy_error());
   }
 
   void ExpectPolicyError(const ExtensionInstallCheckerForTest& checker) {
     ExpectPolicyError(kDummyPolicyError, checker);
   }
 
   void RunChecker(ExtensionInstallCheckerForTest* checker,
                   int expected_result) {
     CheckObserver observer;
     checker->Start(base::Bind(&CheckObserver::OnChecksComplete,
@@ skipping 137 matching lines @@
 
   RunChecker(&checker,
              ExtensionInstallChecker::CHECK_REQUIREMENTS);
 
   ExpectRequirementsError(checker);
   ExpectPolicyPass(checker);
   ExpectBlacklistPass(checker);
 }
 
 }  // namespace extensions