Move ChromeRequirementsChecker to //extensions as a PreloadCheck

extensions/browser/requirements_checker_unittest.cc

Index: extensions/browser/requirements_checker_unittest.cc
diff --git a/extensions/browser/requirements_checker_unittest.cc b/extensions/browser/requirements_checker_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cdaf109b63f69cae9c3a41750c4190c7b1803f68
--- /dev/null
+++ b/extensions/browser/requirements_checker_unittest.cc
@@ -0,0 +1,206 @@
+// 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/requirements_checker.h"
+
+#include <memory>
+#include <vector>
+
+#include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "content/public/browser/gpu_data_manager.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/extensions_test.h"
+#include "extensions/browser/management_policy.h"
+#include "extensions/browser/mock_extension_system.h"
+#include "extensions/browser/preload_check.h"
+#include "extensions/browser/preload_check_test_util.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/file_util.h"
+#include "extensions/common/manifest_handlers/requirements_info.h"
+#include "gpu/config/gpu_info.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace extensions {
+
+namespace {
+
+// Whether this build supports the window.shape requirement.
+const bool kSupportsWindowShape =
+#if defined(USE_AURA)
+    true;
+#else
+    false;
+#endif
+
+// Whether this build supports the plugins.npapi requirement.
+const bool kSupportsNPAPI =
+#if defined(OS_POSIX) && !defined(OS_MACOSX)
+    false;
+#else
+    true;
+#endif
+
+// Returns true if a WebGL check might not fail immediately.
+bool MightSupportWebGL() {
+  return content::GpuDataManager::GetInstance()->GpuAccessAllowed(nullptr);
+}
+
+const char kFeaturesKey[] = "requirements.3D.features";
+const char kFeatureWebGL[] = "webgl";
+const char kFeatureCSS3d[] = "css3d";
+
+}  // namespace
+
+class RequirementsCheckerTest : public ExtensionsTest {
+ public:
+  RequirementsCheckerTest() {
+    manifest_dict_ = base::MakeUnique<base::DictionaryValue>();
+  }
+
+  ~RequirementsCheckerTest() override {}
+
+  void CreateExtension() {
+    manifest_dict_->SetString("name", "dummy name");
+    manifest_dict_->SetString("version", "1");
+
+    std::string error;
+    extension_ =
+        Extension::Create(base::FilePath(), Manifest::UNPACKED, *manifest_dict_,
+                          Extension::NO_FLAGS, &error);
+    EXPECT_TRUE(extension_.get()) << error;
+
+    base::string16 handler_error;
+    ASSERT_TRUE(requirements_handler_.Parse(extension_.get(), &handler_error));

[michaelpg, 2017/03/30 02:36:09]

hmm... so loading/parsing a manifest this way DCHECKs in a couple different
ways. i'll figure out why tomorrow

[michaelpg, 2017/03/30 22:49:01]

Okay, ManifestHandler::Parse can't be called here because the extension has
already "finished" parsing its manifest. We can't register the
RequirementsHandler ourselves; the TestExtensionsClient calls
RegisterCommonManifestHandlers() at startup, then finalizes the registry.

I think the simplest solution is to move RequirementsHandler::Register into
common_manifest_handlers.cc since it doesn't require Chrome. It *does* require
PluginsHandler, though, so that one would also have to be moved to //extensions;
that seems fine, too, 

+  }
+
+ protected:
+  void StartChecker() {
+    checker_ = base::MakeUnique<RequirementsChecker>(extension_.get());
+    runner_.Run(checker_.get());
+  }
+
+  void RequireWindowShape() {
+    manifest_dict_->SetBoolean("requirements.window.shape", true);
+  }
+
+  void RequireNPAPI() {
+    manifest_dict_->SetBoolean("requirements.plugins.npapi", true);
+  }
+
+  void RequireFeature(const char feature[]) {
+    if (!manifest_dict_->HasKey(kFeaturesKey))
+      manifest_dict_->Set(kFeaturesKey, base::MakeUnique<base::ListValue>());
+    base::ListValue* features_list;

[Devlin, 2017/03/30 17:10:55]

nit: initialize to nullptr

[michaelpg, 2017/03/30 22:49:01]

Done.

+    ASSERT_TRUE(manifest_dict_->GetList(kFeaturesKey, &features_list));
+    features_list->AppendString(feature);
+  }
+
+  // This should only be called once per test instance. Calling more than once
+  // will result in stale information in the GPUDataManager which will throw off
+  // the RequirementsChecker.
+  void BlackListGPUFeatures() {
+    static bool called = false;
+    CHECK(!called);

[Devlin, 2017/03/30 17:10:55]

ASSERT_FALSE?

[michaelpg, 2017/03/30 22:49:01]

Done. (This was mostly moved from the browser_test)

+    called = true;
+
+    static const std::string json_blacklist =
+        "{\n"

[Devlin, 2017/03/30 17:10:55]

this would be prettier with raw string literals. :)

Though, FYI, https://codereview.chromium.org/2756793003/ is coming at some
point, and this will be quite a bit shorter then.

[michaelpg, 2017/03/30 22:49:01]

Done.

+        "  \"name\": \"gpu blacklist\",\n"
+        "  \"version\": \"1.0\",\n"
+        "  \"entries\": [\n"
+        "    {\n"
+        "      \"id\": 1,\n"
+        "      \"features\": [\"accelerated_webgl\"]\n"
+        "    }\n"
+        "  ]\n"
+        "}";
+    gpu::GPUInfo gpu_info;
+    content::GpuDataManager::GetInstance()->InitializeForTesting(json_blacklist,
+                                                                 gpu_info);
+  }
+
+  std::unique_ptr<RequirementsChecker> checker_;
+  PreloadCheckRunner runner_;
+
+ private:
+  content::TestBrowserThreadBundle bundle_;
+  RequirementsHandler requirements_handler_;
+  scoped_refptr<Extension> extension_;
+  std::unique_ptr<base::DictionaryValue> manifest_dict_;
+};
+
+// Tests no requirements.
+TEST_F(RequirementsCheckerTest, RequirementsEmpty) {
+  CreateExtension();
+  StartChecker();
+  EXPECT_TRUE(runner_.called());
+  EXPECT_EQ(0u, runner_.errors().size());
+  EXPECT_TRUE(checker_->GetErrorMessage().empty());
+}
+
+// Tests fulfilled requirements.
+TEST_F(RequirementsCheckerTest, RequirementsSuccess) {
+  if (kSupportsWindowShape)
+    RequireWindowShape();
+  if (kSupportsNPAPI)
+    RequireNPAPI();
+  RequireFeature(kFeatureCSS3d);
+
+  CreateExtension();
+  StartChecker();
+  EXPECT_TRUE(runner_.called());
+  EXPECT_EQ(0u, runner_.errors().size());
+  EXPECT_TRUE(checker_->GetErrorMessage().empty());
+}
+
+// Tests multiple requirements failing (on some builds).
+TEST_F(RequirementsCheckerTest, RequirementsFailMultiple) {
+  size_t expected_errors = 0u;
+  if (!kSupportsWindowShape) {
+    RequireWindowShape();
+    expected_errors++;
+  }
+  if (!kSupportsNPAPI) {
+    RequireNPAPI();
+    expected_errors++;
+  }
+  if (!MightSupportWebGL()) {

[Devlin, 2017/03/30 17:10:55]

Won't the blacklist still take effect, even if the check won't fail immediately?

[michaelpg, 2017/03/30 22:49:01]

The blacklist is only set in the following test. The WebGL check may even
succeed synchronously, so we only require it if we're sure it will fail
immediately.

+    RequireFeature(kFeatureWebGL);
+    expected_errors++;
+  }
+  // css3d should always succeed.
+  RequireFeature(kFeatureCSS3d);
+
+  CreateExtension();
+  StartChecker();
+  EXPECT_TRUE(runner_.called());
+  EXPECT_EQ(expected_errors, runner_.errors().size());
+  EXPECT_EQ(expected_errors == 0, checker_->GetErrorMessage().empty());
+}
+
+// Tests a requirement that might fail asynchronously.
+TEST_F(RequirementsCheckerTest, RequirementsFailWebGL) {
+  BlackListGPUFeatures();
+  RequireFeature(kFeatureWebGL);
+  CreateExtension();
+  StartChecker();
+
+  // TODO(michaelpg): Check that the runner actually finishes, which requires
+  // waiting for the GPU check to succeed: crbug.com/706204.
+  runner_.WaitForIdle();
+  if (runner_.errors().size()) {
+    EXPECT_THAT(runner_.errors(), testing::UnorderedElementsAre(
+                                      PreloadCheck::WEBGL_NOT_SUPPORTED));
+    EXPECT_FALSE(checker_->GetErrorMessage().empty());
+  }
+}
+
+}  // namespace extensions