Moving SwiftShader from component to bundled library

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 4587 matching lines @@
                                                     pem_path,
                                                     INSTALL_NEW);
   std::string id = extension_v1->id();
   EXPECT_TRUE(service()->IsExtensionEnabled(id));
 
   base::FilePath v2_bad_requirements_crx = GetTemporaryFile();
 
   PackCRX(path.AppendASCII("v2_bad_requirements"),
           pem_path,
           v2_bad_requirements_crx);
-  UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
-  EXPECT_FALSE(service()->IsExtensionEnabled(id));
+  if (content::GpuDataManager::GetInstance()->ShouldUseSwiftShader()) {
+    UpdateExtension(id, v2_bad_requirements_crx, ENABLED);
+    EXPECT_TRUE(service()->IsExtensionEnabled(id));

[Devlin, 2017/03/02 21:59:29]

Unfortunately, this defeats the purpose of the test, which is checking what
happens when requirements aren't satisfied.  If they are, then we didn't test
anything. :)

[sugoi, 2017/03/06 18:31:42]

I've looked into this, and I still think this is the proper fix. The
BlackListWebGL() function installs GPU info where WebGL is blacklisted, which,
as of this cl, has the effect of enabling SwiftShader, which is the desired
behavior. If I were to make a testing specific fix, it would not represent
reality.

The test is still useful IMHO, since it verifies that, when SwiftShader is
enabled, WebGL doesn't get disabled. Also note that, currently, SwiftShader is
only being enabled on Windows, so the test still behaves as usual on other
platforms.

[Devlin, 2017/03/06 22:58:10]

The thing is, this isn't actually a GPU test, WebGL test, swiftshader test, etc.
 The behavior it's testing is that if an extension is disabled because of
unsupported requirements, and then updates and no longer has unsupported
requirements, it's automatically re-enabled. (See also the comment on line
4587.)  Disabling WebGL was an easy way of triggering an unsupported
requirement, because it's entirely cross-platform and was easy to do from a
unittest, but it's not the sole purpose of the test.  The way it's rewritten
now, we don't actually test the flow that we're supposed to be exercising, so we
lose test coverage.

If we can no longer use webgl as an unavailable requirement, we'll have to
substitute something else or find a test-only way of marking a requirement as
unavailable.

+  } else {
+    UpdateExtension(id, v2_bad_requirements_crx, INSTALLED);
+    EXPECT_FALSE(service()->IsExtensionEnabled(id));
+  }
 
   base::FilePath v3_good_crx = GetTemporaryFile();
 
   PackCRX(path.AppendASCII("v3_good"), pem_path, v3_good_crx);
   UpdateExtension(id, v3_good_crx, ENABLED);
   EXPECT_TRUE(service()->IsExtensionEnabled(id));
 }
 
 // Extensions disabled through user action should stay disabled.
 TEST_F(ExtensionServiceTest, UpgradingRequirementsDisabled) {
@@ skipping 60 matching lines @@
 // Unpacked extensions are not allowed to be installed if they have unsupported
 // requirements.
 TEST_F(ExtensionServiceTest, UnpackedRequirements) {
   InitializeEmptyExtensionService();
   BlackListWebGL();
 
   base::FilePath path =
       data_dir().AppendASCII("requirements").AppendASCII("v2_bad_requirements");
   extensions::UnpackedInstaller::Create(service())->Load(path);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(1u, GetErrors().size());
-  EXPECT_EQ(0u, registry()->enabled_extensions().size());
+  if (content::GpuDataManager::GetInstance()->ShouldUseSwiftShader()) {
+    EXPECT_EQ(0u, GetErrors().size());

[Devlin, 2017/03/02 21:59:29]

ditto here

+    EXPECT_EQ(1u, registry()->enabled_extensions().size());
+  } else {
+    EXPECT_EQ(1u, GetErrors().size());
+    EXPECT_EQ(0u, registry()->enabled_extensions().size());
+  }
 }
 
 class ExtensionCookieCallback {
  public:
   ExtensionCookieCallback()
     : result_(false),
       weak_factory_(base::MessageLoop::current()) {}
 
   void SetCookieCallback(bool result) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 2494 matching lines @@
             shared_module->manifest()->type());
   EXPECT_TRUE(registry()->enabled_extensions().Contains(kExtensionId));
 
   // Reload the extension and wait for it to complete. This previously crashed
   // (see crbug.com/676815).
   service()->ReloadExtension(kExtensionId);
   base::RunLoop().RunUntilIdle();
   // The shared module should be enabled.
   EXPECT_TRUE(registry()->enabled_extensions().Contains(kExtensionId));
 }