extensions: Introduce a fake ExtensionsClient implementation.

And hook it up in our test suite.

The following tests still fail or crash, but for other reasons other than g_client being NULL. Now they are more about FATAL:api_permission_set.cc(125)] Check failed: permission_info.

8 tests failed:
    ExtensionURLPatternTest.ConvertToExplicitSchemes
    ExtensionURLPatternTest.GetAsString
    ExtensionURLPatternTest.Match13
    ExtensionURLPatternTest.Match19
    ExtensionURLPatternTest.Match9
    ExtensionURLPatternTest.Ports
    FileUtilTest.ExtensionResourceURLToFilePath
    FileUtilTest.ExtensionURLToRelativeFilePath
9 tests crashed:
    APIPermissionSetTest.CreateDifference
    APIPermissionSetTest.CreateIntersection
    APIPermissionSetTest.CreateUnion
    APIPermissionSetTest.General
    APIPermissionSetTest.IPC
    APIPermissionSetTest.ImplicitPermissions
    ManifestHandlerTest.DependentHandlers
    ManifestHandlerTest.FailingHandlers
    ManifestHandlerTest.Validate

BUG=348066
TEST=extensions_unittests
R=jamescook@chromium.org,yoz@chromium.org
NOTRY=true

Review URL: https://codereview.chromium.org/234563003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@263573 0039d316-1c4b-4281-b951-d872f2087c98

chrome/common/extensions/permissions/chrome_permission_message_provider.cc

@@ -81,7 +81,6 @@ ChromePermissionMessageProvider::ChromePermissionMessageProvider() {
 ChromePermissionMessageProvider::~ChromePermissionMessageProvider() {
 }
 
-// static
 PermissionMessages ChromePermissionMessageProvider::GetPermissionMessages(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
@@ -117,7 +116,6 @@ PermissionMessages ChromePermissionMessageProvider::GetPermissionMessages(
   return messages;
 }
 
-// static
 std::vector<base::string16> ChromePermissionMessageProvider::GetWarningMessages(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
@@ -187,7 +185,6 @@ std::vector<base::string16> ChromePermissionMessageProvider::GetWarningMessages(
   return message_strings;
 }
 
-// static
 std::vector<base::string16>
 ChromePermissionMessageProvider::GetWarningMessagesDetails(
     const PermissionSet* permissions,
@@ -203,7 +200,6 @@ ChromePermissionMessageProvider::GetWarningMessagesDetails(
   return message_strings;
 }
 
-// static
 bool ChromePermissionMessageProvider::IsPrivilegeIncrease(
     const PermissionSet* old_permissions,
     const PermissionSet* new_permissions,

extensions/extensions.gyp

@@ -20,7 +20,7 @@
         '../chrome/chrome_resources.gyp:chrome_strings',
         # Need default icons in theme_resources.grd
         '../chrome/chrome_resources.gyp:theme_resources',
-        
+
         # TODO(tfarina): This dep here is for extensions/common/constants.*
         # We should find a way to compile this module within extensions_common.
         '../chrome/common_constants.gyp:common_constants',
@@ -493,6 +493,12 @@
         'common/url_pattern_unittest.cc',
         'common/user_script_unittest.cc',
         'test/extensions_unittests_main.cc',
+        'test/test_extensions_client.cc',
+        'test/test_extensions_client.h',
+        'test/test_permission_message_provider.cc',
+        'test/test_permission_message_provider.h',
+        'test/test_permissions_provider.cc',
+        'test/test_permissions_provider.h',
       ],
     },
   ]

extensions/test/extensions_unittests_main.cc

@@ -6,6 +6,7 @@
 #include "base/macros.h"
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_suite.h"
+#include "extensions/test/test_extensions_client.h"
 
 namespace {
 
@@ -13,12 +14,13 @@ class ExtensionsTestSuite : public base::TestSuite {
  public:
   ExtensionsTestSuite(int argc, char** argv);
 
- protected:
+ private:
   // base::TestSuite:
   virtual void Initialize() OVERRIDE;
   virtual void Shutdown() OVERRIDE;
 
- private:
+  scoped_ptr<extensions::TestExtensionsClient> client_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionsTestSuite);
 };
 
@@ -27,6 +29,9 @@ ExtensionsTestSuite::ExtensionsTestSuite(int argc, char** argv)
 
 void ExtensionsTestSuite::Initialize() {
   base::TestSuite::Initialize();
+
+  client_.reset(new extensions::TestExtensionsClient());
+  extensions::ExtensionsClient::Set(client_.get());
 }
 
 void ExtensionsTestSuite::Shutdown() {

extensions/test/test_extensions_client.cc

+// Copyright 2014 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/test/test_extensions_client.h"
+
+#include "extensions/common/common_manifest_handlers.h"
+#include "extensions/common/features/base_feature_provider.h"
+#include "extensions/common/manifest_handler.h"
+#include "extensions/test/test_permission_message_provider.h"
+#include "extensions/test/test_permissions_provider.h"
+
+namespace extensions {
+
+TestExtensionsClient::TestExtensionsClient() {
+}
+
+TestExtensionsClient::~TestExtensionsClient() {
+}
+
+void TestExtensionsClient::Initialize() {
+  // Registration could already be finalized in unit tests, where the utility
+  // thread runs in-process.
+  if (!ManifestHandler::IsRegistrationFinalized()) {
+    RegisterCommonManifestHandlers();
+    ManifestHandler::FinalizeRegistration();
+  }
+}
+
+const PermissionsProvider&
+TestExtensionsClient::GetPermissionsProvider() const {
+  static TestPermissionsProvider provider;
+  return provider;
+}
+
+const PermissionMessageProvider&
+TestExtensionsClient::GetPermissionMessageProvider() const {
+  static TestPermissionMessageProvider provider;
+  return provider;
+}
+
+FeatureProvider* TestExtensionsClient::GetFeatureProviderByName(
+    const std::string& name) const {
+  return BaseFeatureProvider::GetByName(name);
+}
+
+void TestExtensionsClient::FilterHostPermissions(
+    const URLPatternSet& hosts,
+    URLPatternSet* new_hosts,
+    std::set<PermissionMessage>* messages) const {
+}
+
+void TestExtensionsClient::SetScriptingWhitelist(
+    const ExtensionsClient::ScriptingWhitelist& whitelist) {
+  scripting_whitelist_ = whitelist;
+}
+
+const ExtensionsClient::ScriptingWhitelist&
+TestExtensionsClient::GetScriptingWhitelist() const {
+  return scripting_whitelist_;
+}
+
+URLPatternSet TestExtensionsClient::GetPermittedChromeSchemeHosts(
+    const Extension* extension,
+    const APIPermissionSet& api_permissions) const {
+  URLPatternSet hosts;
+  return hosts;
+}
+
+bool TestExtensionsClient::IsScriptableURL(const GURL& url,
+                                           std::string* error) const {
+  return true;
+}
+
+bool TestExtensionsClient::IsAPISchemaGenerated(
+    const std::string& name) const {
+  return false;
+}
+
+base::StringPiece TestExtensionsClient::GetAPISchema(
+    const std::string& name) const {
+  return base::StringPiece();
+}
+
+void TestExtensionsClient::AddExtraFeatureFilters(
+    SimpleFeature* feature) const {
+}
+
+bool TestExtensionsClient::ShouldSuppressFatalErrors() const {
+  return true;
+}
+
+}  // namespace extensions

extensions/test/test_extensions_client.h

+// Copyright 2014 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.
+
+#ifndef EXTENSIONS_TEST_TEST_EXTENSIONS_CLIENT_H_
+#define EXTENSIONS_TEST_TEST_EXTENSIONS_CLIENT_H_
+
+#include "base/macros.h"
+#include "extensions/common/extensions_client.h"
+
+namespace extensions {
+
+class TestExtensionsClient : public ExtensionsClient {
+ public:
+  TestExtensionsClient();
+  virtual ~TestExtensionsClient();
+
+ private:
+  virtual void Initialize() OVERRIDE;
+  virtual const PermissionsProvider& GetPermissionsProvider() const OVERRIDE;
+  virtual const PermissionMessageProvider& GetPermissionMessageProvider() const
+      OVERRIDE;
+  virtual FeatureProvider* GetFeatureProviderByName(
+      const std::string& name) const OVERRIDE;
+  virtual void FilterHostPermissions(
+      const URLPatternSet& hosts,
+      URLPatternSet* new_hosts,
+      std::set<PermissionMessage>* messages) const OVERRIDE;
+  virtual void SetScriptingWhitelist(
+      const ScriptingWhitelist& whitelist) OVERRIDE;
+  virtual const ScriptingWhitelist& GetScriptingWhitelist() const OVERRIDE;
+  virtual URLPatternSet GetPermittedChromeSchemeHosts(
+      const Extension* extension,
+      const APIPermissionSet& api_permissions) const OVERRIDE;
+  virtual bool IsScriptableURL(const GURL& url,
+                               std::string* error) const OVERRIDE;
+  virtual bool IsAPISchemaGenerated(const std::string& name) const OVERRIDE;
+  virtual base::StringPiece GetAPISchema(
+      const std::string& name) const OVERRIDE;
+  virtual void AddExtraFeatureFilters(SimpleFeature* feature) const OVERRIDE;
+  virtual bool ShouldSuppressFatalErrors() const OVERRIDE;
+
+  // A whitelist of extensions that can script anywhere. Do not add to this
+  // list (except in tests) without consulting the Extensions team first.
+  // Note: Component extensions have this right implicitly and do not need to be
+  // added to this list.
+  ScriptingWhitelist scripting_whitelist_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestExtensionsClient);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_TEST_TEST_EXTENSIONS_CLIENT_H_

extensions/test/test_permission_message_provider.cc

+// Copyright 2014 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/test/test_permission_message_provider.h"
+
+namespace extensions {
+
+TestPermissionMessageProvider::TestPermissionMessageProvider() {
+}
+
+TestPermissionMessageProvider::~TestPermissionMessageProvider() {
+}
+
+PermissionMessages TestPermissionMessageProvider::GetPermissionMessages(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type) const {
+  return PermissionMessages();
+}
+
+std::vector<base::string16> TestPermissionMessageProvider::GetWarningMessages(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type) const {
+  return std::vector<base::string16>();
+}
+
+std::vector<base::string16>
+TestPermissionMessageProvider::GetWarningMessagesDetails(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type) const {
+  return std::vector<base::string16>();
+}
+
+bool TestPermissionMessageProvider::IsPrivilegeIncrease(
+    const PermissionSet* old_permissions,
+    const PermissionSet* new_permissions,
+    Manifest::Type extension_type) const {
+  return false;
+}
+
+}  // namespace extensions

extensions/test/test_permission_message_provider.h

+// Copyright 2014 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.
+
+#ifndef EXTENSIONS_TEST_TEST_PERMISSION_MESSAGE_PROVIDER_H_
+#define EXTENSIONS_TEST_TEST_PERMISSION_MESSAGE_PROVIDER_H_
+
+#include "base/macros.h"
+#include "extensions/common/permissions/permission_message_provider.h"
+
+namespace extensions {
+
+class TestPermissionMessageProvider : public PermissionMessageProvider {
+ public:
+  TestPermissionMessageProvider();
+  virtual ~TestPermissionMessageProvider();
+
+ private:
+  virtual PermissionMessages GetPermissionMessages(
+      const PermissionSet* permissions,
+      Manifest::Type extension_type) const OVERRIDE;
+  virtual std::vector<base::string16> GetWarningMessages(
+      const PermissionSet* permissions,
+      Manifest::Type extension_type) const OVERRIDE;
+  virtual std::vector<base::string16> GetWarningMessagesDetails(
+      const PermissionSet* permissions,
+      Manifest::Type extension_type) const OVERRIDE;
+  virtual bool IsPrivilegeIncrease(
+      const PermissionSet* old_permissions,
+      const PermissionSet* new_permissions,
+      Manifest::Type extension_type) const OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(TestPermissionMessageProvider);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_TEST_TEST_PERMISSION_MESSAGE_PROVIDER_H_

extensions/test/test_permissions_provider.cc

+// Copyright 2014 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/test/test_permissions_provider.h"
+
+namespace extensions {
+
+TestPermissionsProvider::TestPermissionsProvider() {}
+
+TestPermissionsProvider::~TestPermissionsProvider() {}
+
+std::vector<APIPermissionInfo*> TestPermissionsProvider::GetAllPermissions()
+    const {
+  // TODO(tfarina): This needs to have a "real" implementation, otherwise
+  // some tests under extensions_unittests will fail. http://crbug.com/348066
+  std::vector<APIPermissionInfo*> permissions;
+  return permissions;
+}
+
+std::vector<PermissionsProvider::AliasInfo>
+TestPermissionsProvider::GetAllAliases() const {
+  std::vector<PermissionsProvider::AliasInfo> aliases;
+  return aliases;
+}
+
+}  // namespace extensions

extensions/test/test_permissions_provider.h

+// Copyright 2014 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.
+
+#ifndef EXTENSIONS_TEST_TEST_PERMISSIONS_PROVIDER_H_
+#define EXTENSIONS_TEST_TEST_PERMISSIONS_PROVIDER_H_
+
+#include "base/macros.h"
+#include "extensions/common/permissions/permissions_provider.h"
+
+namespace extensions {
+
+class TestPermissionsProvider : public PermissionsProvider {
+ public:
+  TestPermissionsProvider();
+  virtual ~TestPermissionsProvider();
+
+ private:
+  // PermissionsProvider:
+  virtual std::vector<APIPermissionInfo*> GetAllPermissions() const OVERRIDE;
+  virtual std::vector<AliasInfo> GetAllAliases() const OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(TestPermissionsProvider);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_TEST_TEST_PERMISSIONS_PROVIDER_H_