"Redirecting URLs to Packaged Apps" implementation: revised

chrome/common/extensions/api/url_handlers/url_handlers_parser.cc

+// Copyright 2013 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/common/extensions/api/url_handlers/url_handlers_parser.h"
+
+#include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/manifest_handlers/offline_enabled_info.h"
+#include "extensions/common/error_utils.h"
+#include "extensions/common/switches.h"
+#include "net/base/network_change_notifier.h"
+#include "url/gurl.h"
+
+using base::ASCIIToUTF16;
+using net::NetworkChangeNotifier;
+
+namespace mkeys = extensions::manifest_keys;
+namespace merrors = extension_manifest_errors;
+
+// TODO(sergeygs): Use the same strategy that externally_connectable does for
+// parsing the manifest: declare a schema for the manifest entry in
+// manifest_types.json, then use it here.
+//
+// See:
+// chrome/common/extensions/api/manifest_types.json
+// chrome/common/extensions/manifest_handlers/externally_connectable.*
+//
+// Do the same in (at least) file_handlers_parser.cc as well.
+
+namespace extensions {
+
+UrlHandlerInfo::UrlHandlerInfo() {
+}
+
+UrlHandlerInfo::~UrlHandlerInfo() {
+}
+
+UrlHandlers::UrlHandlers() {
+}
+
+UrlHandlers::~UrlHandlers() {
+}
+
+// static
+const std::vector<UrlHandlerInfo>* UrlHandlers::GetUrlHandlers(
+    const Extension* extension) {
+  UrlHandlers* info = static_cast<UrlHandlers*>(
+      extension->GetManifestData(mkeys::kUrlHandlers));
+  return info ? &info->handlers : NULL;
+}
+
+// static
+bool UrlHandlers::CanExtensionHandleUrl(
+    const Extension* extension,
+    const GURL& url) {
+  return FindMatchingUrlHandler(extension, url) != NULL;
+}
+
+// static
+const UrlHandlerInfo* UrlHandlers::FindMatchingUrlHandler(
+    const Extension* extension,
+    const GURL& url) {
+  const std::vector<UrlHandlerInfo>* handlers = GetUrlHandlers(extension);
+  if (!handlers)
+    return NULL;
+
+  if (NetworkChangeNotifier::IsOffline() &&
+      !OfflineEnabledInfo::IsOfflineEnabled(extension))
+    return NULL;
+
+  for (std::vector<extensions::UrlHandlerInfo>::const_iterator it =
+       handlers->begin(); it != handlers->end(); it++) {
+    if (it->patterns.MatchesURL(url))
+      return &(*it);
+  }
+
+  return NULL;
+}
+
+UrlHandlersParser::UrlHandlersParser() {
+}
+
+UrlHandlersParser::~UrlHandlersParser() {
+}
+
+bool ParseUrlHandler(const std::string& handler_id,
+                     const DictionaryValue& handler_info,
+                     std::vector<UrlHandlerInfo>* url_handlers,
+                     string16* error) {
+  DCHECK(error);
+
+  UrlHandlerInfo handler;
+  handler.id = handler_id;
+
+  if (!handler_info.GetString(mkeys::kUrlHandlerTitle, &handler.title)) {
+    *error = ASCIIToUTF16(merrors::kInvalidURLHandlerTitle);
+    return false;
+  }
+
+  const ListValue* manif_patterns = NULL;
+  if (!handler_info.GetList(mkeys::kMatches, &manif_patterns) ||
+      manif_patterns->GetSize() == 0) {
+    *error = ErrorUtils::FormatErrorMessageUTF16(
+        merrors::kInvalidURLHandlerPattern, handler_id);
+    return false;
+  }
+
+  for (ListValue::const_iterator it = manif_patterns->begin();
+       it != manif_patterns->end(); ++it) {
+    std::string str_pattern;
+    (*it)->GetAsString(&str_pattern);
+    URLPattern pattern(URLPattern::SCHEME_HTTP |
+                       URLPattern::SCHEME_HTTPS);
+    if (pattern.Parse(str_pattern) != URLPattern::PARSE_SUCCESS) {
+      *error = ErrorUtils::FormatErrorMessageUTF16(
+          merrors::kInvalidURLHandlerPatternElement, handler_id);
+      return false;
+    }
+    handler.patterns.AddPattern(pattern);

[not at google - send to devlin, 2013/09/09 22:25:35]

Please also add TODO(..) to restrict this feature to non-TLDs, like
externally_connectable does.

and then, another TODO to further restrict it to only what the webstore tells
it.

[sergeygs, 2013/09/09 23:41:39]

Done.

+  }
+
+  url_handlers->push_back(handler);
+
+  return true;
+}
+
+bool UrlHandlersParser::Parse(Extension* extension, string16* error) {
+  scoped_ptr<UrlHandlers> info(new UrlHandlers);
+  const DictionaryValue* all_handlers = NULL;
+  if (!extension->manifest()->GetDictionary(
+        mkeys::kUrlHandlers, &all_handlers)) {
+    *error = ASCIIToUTF16(merrors::kInvalidURLHandlers);
+    return false;
+  }
+
+  DCHECK(extension->is_platform_app());
+
+  for (DictionaryValue::Iterator iter(*all_handlers); !iter.IsAtEnd();
+       iter.Advance()) {
+    // A URL handler entry is a title and a list of URL patterns to handle.
+    const DictionaryValue* handler = NULL;
+    if (!iter.value().GetAsDictionary(&handler)) {
+      *error = ASCIIToUTF16(merrors::kInvalidURLHandlerPatternElement);
+      return false;
+    }
+
+    if (!ParseUrlHandler(iter.key(), *handler, &info->handlers, error)) {
+      // Text in |error| is set by ParseUrlHandler.
+      return false;
+    }
+  }
+
+  extension->SetManifestData(mkeys::kUrlHandlers, info.release());
+
+  return true;
+}
+
+const std::vector<std::string> UrlHandlersParser::Keys() const {
+  return SingleKey(mkeys::kUrlHandlers);
+}
+
+}  // namespace extensions