Enforce the 'requirements' field in manifests.

chrome/browser/extensions/requirements_checker.cc

+// Copyright (c) 2012 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/requirements_checker.h"
+
+#include "base/bind.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/gpu_feature_checker.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/manifest.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/gpu_feature_type.h"
+
+namespace keys = extension_manifest_keys;
+
+namespace {
+
+const char* kWebGlError = "WebGL is not supported";
+const char* kCSS3dError = "CSS3d is not supported";
+#if defined(OS_CHROMEOS)
+const char* kPluginsError = "Plugins are not supported";
+#endif
+
+}  // namespace
+
+namespace extensions {
+
+bool RequirementsChecker::checked_for_webgl_ = false;
+bool RequirementsChecker::webgl_supported_ = false;
+bool RequirementsChecker::checked_for_css3d_ = false;
+bool RequirementsChecker::css3d_supported_ = false;
+
+RequirementsChecker::RequirementsChecker()
+    : async_requirement_checks_(0) {
+}
+
+RequirementsChecker::~RequirementsChecker() {
+}
+
+void RequirementsChecker::Check(scoped_refptr<const Extension> extension,
+    base::Callback<void(std::vector<std::string>)> callback,
+    content::BrowserThread::ID callback_thread) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  callback_ = callback;
+  callback_thread_ = callback_thread;
+  DictionaryValue* requirements_value = NULL;
+  extension->manifest()->GetDictionary(keys::kRequirements,
+                                       &requirements_value);
+  if (!requirements_value) {
+    content::BrowserThread::PostTask(callback_thread_, FROM_HERE,
+        base::Bind(&RequirementsChecker::CallbackOnCorrectThread,
+                   base::Unretained(this)));

[Aaron Boodman, 2012/07/30 12:15:11]

Unretained is almost always a bad idea. If this class goes away while the task
is outstanding, the callback will crash. If you use WeakPtr instead, it will
prevent the callback from being executed if this class goes away.

[eaugusti, 2012/07/30 20:03:17]

Done.

+    return;
+  }
+
+  for (DictionaryValue::key_iterator it = requirements_value->begin_keys();
+       it != requirements_value->end_keys(); ++it) {
+    DictionaryValue* requirement_value;
+    if (!requirements_value->GetDictionaryWithoutPathExpansion(*it,
+        &requirement_value) || !requirement_value) {
+      continue;
+    }
+
+    if (*it == "plugins") {
+#if defined(OS_CHROMEOS)
+      errors_.push_back(kPluginsError);
+#endif
+    } else if (*it == "3D") {
+      ListValue* features;
+      if (!requirement_value->GetListWithoutPathExpansion("features",
+                                                          &features) ||
+          !features) {
+        errors_.push_back("Improperly formatted requirement features for 3D");
+        continue;
+      }
+
+      std::string feature;
+      base::ListValue::iterator it;
+      for (it = features->begin(); it != features->end(); ++it) {
+        if ((*it)->GetAsString(&feature)) {
+          if (feature == "webgl") {
+            if (checked_for_webgl_) {
+              if (!webgl_supported_)
+                errors_.push_back(kWebGlError);
+            } else {
+              ++async_requirement_checks_;
+              webgl_checker_ = new GPUFeatureChecker(
+                  content::GPU_FEATURE_TYPE_WEBGL,
+                  base::Bind(&RequirementsChecker::IsWebGLAvailable,
+                             base::Unretained(this)));
+            }
+          } else if (feature == "css3d") {
+            if (checked_for_css3d_) {
+              if (!css3d_supported_) {
+                errors_.push_back(kCSS3dError);
+              }
+            } else {
+              ++async_requirement_checks_;
+              css3d_checker_ = new GPUFeatureChecker(
+                  content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
+                  base::Bind(&RequirementsChecker::IsCSS3dAvailable,
+                             base::Unretained(this)));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (!async_requirement_checks_) {
+    content::BrowserThread::PostTask(callback_thread_, FROM_HERE,
+        base::Bind(&RequirementsChecker::CallbackOnCorrectThread,
+                   base::Unretained(this)));
+    return;
+  }
+  // Running the GPU checkers down here removes any race condition that arises
+  // from the use of async_requirement_checks_.
+  if (webgl_checker_.get())
+    webgl_checker_->CheckGPUFeatureAvailability();
+  if (css3d_checker_.get())
+    css3d_checker_->CheckGPUFeatureAvailability();
+}
+
+void RequirementsChecker::IsWebGLAvailable(bool available) {
+  webgl_supported_ = available;
+  checked_for_webgl_ = true;
+  if (!webgl_supported_)
+    errors_.push_back(kWebGlError);
+  MaybeRunCallback();
+}
+
+void RequirementsChecker::IsCSS3dAvailable(bool available) {
+  css3d_supported_ = available;
+  checked_for_css3d_ = true;
+  if (!css3d_supported_)
+    errors_.push_back(kCSS3dError);
+  MaybeRunCallback();
+}
+
+void RequirementsChecker::MaybeRunCallback() {
+  async_requirement_checks_lock_.Acquire();
+  if (!--async_requirement_checks_) {
+    content::BrowserThread::PostTask(callback_thread_, FROM_HERE,
+        base::Bind(&RequirementsChecker::CallbackOnCorrectThread,
+                   base::Unretained(this)));
+  }
+  async_requirement_checks_lock_.Release();
+}
+
+void RequirementsChecker::CallbackOnCorrectThread() {
+  DCHECK(content::BrowserThread::CurrentlyOn(callback_thread_));
+  callback_.Run(errors_);
+}
+
+}  // namespace extensions