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/08 22:30:40]

This can be removed, since you're no longer testing GPU functionality with 
ExtensionWebstorePrivateApiTest.

+    // 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 64 matching lines @@
 
     ASSERT_FALSE(destination.empty());
     ASSERT_EQ(destination, crx_path);
 
     test_crx_.push_back(destination);
   }
 
   std::vector<FilePath> test_crx_;
 };
 
+class ExtensionWebstoreGetWebGLStatusTest : public InProcessBrowserTest {
+ public:
+  void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    // In linux, we need to launch GPU process to decide if WebGL is allowed.
+    // 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
+  }
+
+ protected:
+  void RunTest(bool webgl_allowed) {
+    static const char kEmptyArgs[] = "[]";
+    static const char kWebGLStatusAllowed[] = "webgl_allowed";
+    static const char kWebGLStatusBlocked[] = "webgl_blocked";
+    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 ? kWebGLStatusAllowed : kWebGLStatusBlocked,
+                 webgl_status.c_str());
+  }
+
+};
+
 // Test cases where the user accepts the install confirmation dialog.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest, InstallAccepted) {
   ASSERT_TRUE(RunInstallTest("accepted.html", "extension.crx"));
 }
 
 // Tests passing a localized name.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest, InstallLocalized) {
   ASSERT_TRUE(RunInstallTest("localized.html", "localized_extension.crx"));
 }
 
@@ skipping 39 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(ExtensionWebstoreGetWebGLStatusTest, Allowed) {
+  bool webgl_allowed = true;
+  RunTest(webgl_allowed);
+}
+
+// Tests getWebGLStatus function when WebGL is blacklisted.
+IN_PROC_BROWSER_TEST_F(ExtensionWebstoreGetWebGLStatusTest, Blocked) {
+  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));
+
+  bool webgl_allowed = false;
+  RunTest(webgl_allowed);
+}
+