Add support for loading extensions (issue #1947)

- Add CefRequestContext::LoadExtension, CefExtension, CefExtensionHandler and
  related methods/interfaces.
- Add chrome://extensions-support that lists supported Chrome APIs.
- Add CefBrowserHost::SetAutoResizeEnabled and CefDisplayHandler::OnAutoResize
  to support browser resize based on preferred web contents size.
- views: Add support for custom CefMenuButton popups.
- cefclient: Run with `--load-extension=set_page_color` command-line flag for
  an extension loading example. Add `--use-views` on Windows and Linux for an
  even better example.

tests/shared/browser/extension_util.cc

@@ -0,0 +1,239 @@
+// Copyright (c) 2017 The Chromium Embedded Framework 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 "tests/shared/browser/extension_util.h"
+
+#include "include/base/cef_bind.h"
+#include "include/cef_parser.h"
+#include "include/cef_path_util.h"
+#include "include/wrapper/cef_closure_task.h"
+#include "tests/shared/browser/file_util.h"
+#include "tests/shared/browser/resource_util.h"
+
+namespace client {
+namespace extension_util {
+
+namespace {
+
+std::string GetResourcesPath() {
+  CefString resources_dir;
+  if (CefGetPath(PK_DIR_RESOURCES, resources_dir) && !resources_dir.empty()) {
+    return resources_dir.ToString() + file_util::kPathSep;
+  }
+  return std::string();
+}
+
+// Internal extension paths may be prefixed with PK_DIR_RESOURCES and always
+// use forward slash as path separator.
+std::string GetInternalPath(const std::string& extension_path) {
+  const std::string& resources_path = GetResourcesPath();
+  std::string internal_path;
+  if (!resources_path.empty() && extension_path.find(resources_path) == 0U) {
+    internal_path = extension_path.substr(resources_path.size());
+  } else {
+    internal_path = extension_path;
+  }
+
+#if defined(OS_WIN)
+  // Normalize path separators.
+  std::replace(internal_path.begin(), internal_path.end(), '\\', '/');
+#endif
+
+  return internal_path;
+}
+
+typedef base::Callback<void(CefRefPtr<CefDictionaryValue> /*manifest*/)>
+    ManifestCallback;
+
+void RunManifestCallback(const ManifestCallback& callback,
+                         CefRefPtr<CefDictionaryValue> manifest) {
+  if (!CefCurrentlyOn(TID_UI)) {
+    // Execute on the browser UI thread.
+    CefPostTask(TID_UI, base::Bind(RunManifestCallback, callback, manifest));
+    return;
+  }
+  callback.Run(manifest);
+}
+
+// Asynchronously reads the manifest and executes |callback| on the UI thread.
+void GetInternalManifest(const std::string& extension_path,
+                         const ManifestCallback& callback) {
+  if (!CefCurrentlyOn(TID_FILE)) {
+    // Execute on the browser FILE thread.
+    CefPostTask(TID_FILE,
+                base::Bind(GetInternalManifest, extension_path, callback));
+    return;
+  }
+
+  const std::string& manifest_path = GetInternalExtensionResourcePath(
+      file_util::JoinPath(extension_path, "manifest.json"));
+  std::string manifest_contents;
+  if (!LoadBinaryResource(manifest_path.c_str(), manifest_contents) ||
+      manifest_contents.empty()) {
+    LOG(ERROR) << "Failed to load manifest from " << manifest_path;
+    RunManifestCallback(callback, NULL);
+    return;
+  }
+
+  cef_json_parser_error_t error_code;
+  CefString error_msg;
+  CefRefPtr<CefValue> value = CefParseJSONAndReturnError(
+      manifest_contents, JSON_PARSER_RFC, error_code, error_msg);
+  if (!value || value->GetType() != VTYPE_DICTIONARY) {
+    if (error_msg.empty())
+      error_msg = "Incorrectly formatted dictionary contents.";
+    LOG(ERROR) << "Failed to parse manifest from " << manifest_path << "; "
+               << error_msg.ToString();
+    RunManifestCallback(callback, NULL);
+    return;
+  }
+
+  RunManifestCallback(callback, value->GetDictionary());
+}
+
+void LoadExtensionWithManifest(CefRefPtr<CefRequestContext> request_context,
+                               const std::string& extension_path,
+                               CefRefPtr<CefExtensionHandler> handler,
+                               CefRefPtr<CefDictionaryValue> manifest) {
+  CEF_REQUIRE_UI_THREAD();
+
+  // Load the extension internally. Resource requests will be handled via
+  // AddInternalExtensionToResourceManager.
+  request_context->LoadExtension(extension_path, manifest, handler);
+}
+
+}  // namespace
+
+bool IsInternalExtension(const std::string& extension_path) {
+  // List of internally handled extensions.
+  static const char* extensions[] = {"set_page_color"};
+
+  const std::string& internal_path = GetInternalPath(extension_path);
+  for (size_t i = 0; i < arraysize(extensions); ++i) {
+    // Exact match or first directory component.
+    const std::string& extension = extensions[i];
+    if (internal_path == extension ||
+        internal_path.find(extension + '/') == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+std::string GetInternalExtensionResourcePath(
+    const std::string& extension_path) {
+  return "extensions/" + GetInternalPath(extension_path);
+}
+
+std::string GetExtensionResourcePath(const std::string& extension_path,
+                                     bool* internal) {
+  const bool is_internal = IsInternalExtension(extension_path);
+  if (internal)
+    *internal = is_internal;
+  if (is_internal)
+    return GetInternalExtensionResourcePath(extension_path);
+  return extension_path;
+}
+
+bool GetExtensionResourceContents(const std::string& extension_path,
+                                  std::string& contents) {
+  CEF_REQUIRE_FILE_THREAD();
+
+  if (IsInternalExtension(extension_path)) {
+    const std::string& contents_path =
+        GetInternalExtensionResourcePath(extension_path);
+    return LoadBinaryResource(contents_path.c_str(), contents);
+  }
+
+  return file_util::ReadFileToString(extension_path, &contents);
+}
+
+void LoadExtension(CefRefPtr<CefRequestContext> request_context,
+                   const std::string& extension_path,
+                   CefRefPtr<CefExtensionHandler> handler) {
+  if (!CefCurrentlyOn(TID_UI)) {
+    // Execute on the browser UI thread.
+    CefPostTask(TID_UI, base::Bind(LoadExtension, request_context,
+                                   extension_path, handler));
+    return;
+  }
+
+  if (IsInternalExtension(extension_path)) {
+    // Read the extension manifest and load asynchronously.
+    GetInternalManifest(extension_path,
+                        base::Bind(LoadExtensionWithManifest, request_context,
+                                   extension_path, handler));
+  } else {
+    // Load the extension from disk.
+    request_context->LoadExtension(extension_path, NULL, handler);
+  }
+}
+
+void AddInternalExtensionToResourceManager(
+    CefRefPtr<CefExtension> extension,
+    CefRefPtr<CefResourceManager> resource_manager) {
+  DCHECK(IsInternalExtension(extension->GetPath()));
+
+  if (!CefCurrentlyOn(TID_IO)) {
+    // Execute on the browser IO thread.
+    CefPostTask(TID_IO, base::Bind(AddInternalExtensionToResourceManager,
+                                   extension, resource_manager));
+    return;
+  }
+
+  const std::string& origin = GetExtensionOrigin(extension->GetIdentifier());
+  const std::string& resource_path =
+      GetInternalExtensionResourcePath(extension->GetPath());
+
+// Add provider for bundled resource files.
+#if defined(OS_WIN)
+  // Read resources from the binary.
+  resource_manager->AddProvider(
+      CreateBinaryResourceProvider(origin, resource_path), 50, std::string());
+#elif defined(OS_POSIX)
+  // Read resources from a directory on disk.
+  std::string resource_dir;
+  if (GetResourceDir(resource_dir)) {
+    resource_dir += "/" + resource_path;
+    resource_manager->AddDirectoryProvider(origin, resource_dir, 50,
+                                           std::string());
+  }
+#endif
+}
+
+std::string GetExtensionOrigin(const std::string& extension_id) {
+  return "chrome-extension://" + extension_id + "/";
+}
+
+std::string GetExtensionURL(CefRefPtr<CefExtension> extension) {
+  CefRefPtr<CefDictionaryValue> browser_action =
+      extension->GetManifest()->GetDictionary("browser_action");
+  if (browser_action) {
+    const std::string& default_popup =
+        browser_action->GetString("default_popup");
+    if (!default_popup.empty())
+      return GetExtensionOrigin(extension->GetIdentifier()) + default_popup;
+  }
+
+  return std::string();
+}
+
+std::string GetExtensionIconPath(CefRefPtr<CefExtension> extension,
+                                 bool* internal) {
+  CefRefPtr<CefDictionaryValue> browser_action =
+      extension->GetManifest()->GetDictionary("browser_action");
+  if (browser_action) {
+    const std::string& default_icon = browser_action->GetString("default_icon");
+    if (!default_icon.empty()) {
+      return GetExtensionResourcePath(
+          file_util::JoinPath(extension->GetPath(), default_icon), internal);
+    }
+  }
+
+  return std::string();
+}
+
+}  // namespace extension_util
+}  // namespace client