Add a JS API for detecting WebGL availability.

chrome/browser/extensions/extension_webstore_private_apitest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_install_dialog.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_webstore_private_api.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "content/browser/gpu/gpu_blacklist.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "net/base/mock_host_resolver.h"
+#include "ui/gfx/gl/gl_switches.h"
+
+using namespace extension_function_test_utils;
 
 namespace {
 
 class WebstoreInstallListener : public WebstoreInstaller::Delegate {
  public:
   WebstoreInstallListener()
       : received_failure_(false), received_success_(false), waiting_(false) {}
 
   void OnExtensionInstallSuccess(const std::string& id) OVERRIDE;
   void OnExtensionInstallFailure(const std::string& id,
@@ skipping 45 matching lines @@
 
 }  // namespace
 
 // A base class for tests below.
 class ExtensionWebstorePrivateApiTest : public ExtensionApiTest {
  public:
   void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     ExtensionApiTest::SetUpCommandLine(command_line);
     command_line->AppendSwitchASCII(switches::kAppsGalleryURL,
         "http://www.example.com");
+
+    // In linux, we need to launch GPU process to decide if WebGL is allowed.

[Mihai Parparita -not on Chrome, 2011/12/07 00:01:38]

Can you move this to a separate subclass that you use for the GPU function
tests? Also, that subclass doesn't need to extend ExtensionApiTest, it can just
use InProcessBrowserTest.

[Zhenyao Mo, 2011/12/07 17:26:51]

Done.

+    // Run it on top of osmesa to avoid bot driver issues.
+#if defined(OS_LINUX)
+    CHECK(test_launcher_utils::OverrideGLImplementation(
+        command_line, gfx::kGLImplementationOSMesaName)) <<
+        "kUseGL must not be set multiple times!";
+#endif
   }
 
   void SetUpInProcessBrowserTestFixture() OVERRIDE {
     // Start up the test server and get us ready for calling the install
     // API functions.
     host_resolver()->AddRule("www.example.com", "127.0.0.1");
     ASSERT_TRUE(test_server()->Start());
     SetExtensionInstallDialogAutoConfirmForTests(true);
     ExtensionInstallUI::DisableFailureUIForTests();
   }
@@ skipping 123 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
                        IconUrl) {
   ASSERT_TRUE(RunInstallTest("icon_url.html", "extension.crx"));
 }
 
 // Tests using silentlyInstall to install extensions.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateBundleTest, SilentlyInstall) {
   WebstorePrivateApi::SetTrustTestIDsForTesting(true);
   ASSERT_TRUE(RunPageTest(GetTestServerURL("silently_install.html").spec()));
 }
+
+// Tests getWebGLStatus function when WebGL is allowed.
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       GetWebGLStatusAllowed) {

[Ken Russell (switch to Gerrit), 2011/12/06 22:42:04]

Are these tests run in the same process, and if so, isn't there a dependency in
the order of running these tests? Since this one doesn't initialize the
blacklist in the GpuDataManager, it expects to run before the one following it.
Could you try switching their order in the file and see if this starts failing?
If it does then more setup code is needed.

+  static const char kEmptyArgs[] = "[]";
+  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
+          new GetWebGLStatusFunction(), kEmptyArgs, browser()));
+  EXPECT_EQ(base::Value::TYPE_STRING, result->GetType());
+  StringValue* value = static_cast<StringValue*>(result.get());
+  std::string webgl_status = "";
+  EXPECT_TRUE(value && value->GetAsString(&webgl_status));
+  EXPECT_STREQ("webgl_allowed", webgl_status.c_str());
+}
+
+// Tests getWebGLStatus function when WebGL is blacklisted.
+IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
+                       GetWebGLStatusBlocked) {
+  static const std::string json_blacklist =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"1.0\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": 1,\n"
+      "      \"blacklist\": [\n"
+      "        \"webgl\"\n"
+      "      ]\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("1.0"));
+  GpuBlacklist* blacklist = new GpuBlacklist("1.0");
+
+  ASSERT_TRUE(blacklist->LoadGpuBlacklist(
+      json_blacklist, GpuBlacklist::kAllOs));
+  GpuDataManager::GetInstance()->SetGpuBlacklist(blacklist);
+  GpuFeatureFlags flags = GpuDataManager::GetInstance()->GetGpuFeatureFlags();
+  EXPECT_EQ(
+      flags.flags(), static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
+
+  static const char kEmptyArgs[] = "[]";
+  scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
+          new GetWebGLStatusFunction(), kEmptyArgs, browser()));
+  EXPECT_EQ(base::Value::TYPE_STRING, result->GetType());
+  StringValue* value = static_cast<StringValue*>(result.get());
+  std::string webgl_status = "";
+  EXPECT_TRUE(value && value->GetAsString(&webgl_status));
+  EXPECT_STREQ("webgl_blocked", webgl_status.c_str());
+}
+