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

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/common/extensions/api/url_handlers/url_handlers_parser.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/values.h"
  12 #include "extensions/common/error_utils.h"
  13 #include "extensions/common/manifest_constants.h"
  14 #include "extensions/common/manifest_handlers/offline_enabled_info.h"
  15 #include "extensions/common/switches.h"
  16 #include "net/base/network_change_notifier.h"
  17 #include "url/gurl.h"
  18
  19 using base::ASCIIToUTF16;
  20 using net::NetworkChangeNotifier;
  21
  22 // TODO(sergeygs): Use the same strategy that externally_connectable does for
  23 // parsing the manifest: declare a schema for the manifest entry in
  24 // manifest_types.json, then use it here.
  25 //
  26 // See:
  27 // chrome/common/extensions/api/manifest_types.json
  28 // chrome/common/extensions/manifest_handlers/externally_connectable.*
  29 //
  30 // Do the same in (at least) file_handlers_parser.cc as well.
  31
  32 namespace extensions {
  33
  34 namespace mkeys = manifest_keys;
  35 namespace merrors = manifest_errors;
  36
  37 UrlHandlerInfo::UrlHandlerInfo() {
  38 }
  39
  40 UrlHandlerInfo::~UrlHandlerInfo() {
  41 }
  42
  43 UrlHandlers::UrlHandlers() {
  44 }
  45
  46 UrlHandlers::~UrlHandlers() {
  47 }
  48
  49 // static
  50 const std::vector<UrlHandlerInfo>* UrlHandlers::GetUrlHandlers(
  51     const Extension* extension) {
  52   UrlHandlers* info = static_cast<UrlHandlers*>(
  53       extension->GetManifestData(mkeys::kUrlHandlers));
  54   return info ? &info->handlers : NULL;
  55 }
  56
  57 // static
  58 bool UrlHandlers::CanExtensionHandleUrl(
  59     const Extension* extension,
  60     const GURL& url) {
  61   return FindMatchingUrlHandler(extension, url) != NULL;
  62 }
  63
  64 // static
  65 const UrlHandlerInfo* UrlHandlers::FindMatchingUrlHandler(
  66     const Extension* extension,
  67     const GURL& url) {
  68   const std::vector<UrlHandlerInfo>* handlers = GetUrlHandlers(extension);
  69   if (!handlers)
  70     return NULL;
  71
  72   if (NetworkChangeNotifier::IsOffline() &&
  73       !OfflineEnabledInfo::IsOfflineEnabled(extension))
  74     return NULL;
  75
  76   for (std::vector<extensions::UrlHandlerInfo>::const_iterator it =
  77        handlers->begin(); it != handlers->end(); it++) {
  78     if (it->patterns.MatchesURL(url))
  79       return &(*it);
  80   }
  81
  82   return NULL;
  83 }
  84
  85 UrlHandlersParser::UrlHandlersParser() {
  86 }
  87
  88 UrlHandlersParser::~UrlHandlersParser() {
  89 }
  90
  91 bool ParseUrlHandler(const std::string& handler_id,
  92                      const base::DictionaryValue& handler_info,
  93                      std::vector<UrlHandlerInfo>* url_handlers,
  94                      base::string16* error) {
  95   DCHECK(error);
  96
  97   UrlHandlerInfo handler;
  98   handler.id = handler_id;
  99
 100   if (!handler_info.GetString(mkeys::kUrlHandlerTitle, &handler.title)) {
 101     *error = base::ASCIIToUTF16(merrors::kInvalidURLHandlerTitle);
 102     return false;
 103   }
 104
 105   const base::ListValue* manif_patterns = NULL;
 106   if (!handler_info.GetList(mkeys::kMatches, &manif_patterns) ||
 107       manif_patterns->GetSize() == 0) {
 108     *error = ErrorUtils::FormatErrorMessageUTF16(
 109         merrors::kInvalidURLHandlerPattern, handler_id);
 110     return false;
 111   }
 112
 113   for (base::ListValue::const_iterator it = manif_patterns->begin();
 114        it != manif_patterns->end(); ++it) {
 115     std::string str_pattern;
 116     (*it)->GetAsString(&str_pattern);
 117     // TODO(sergeygs): Limit this to non-top-level domains.
 118     // TODO(sergeygs): Also add a verification to the CWS installer that the
 119     // URL patterns claimed here belong to the app's author verified sites.
 120     URLPattern pattern(URLPattern::SCHEME_HTTP |
 121                        URLPattern::SCHEME_HTTPS);
 122     if (pattern.Parse(str_pattern) != URLPattern::PARSE_SUCCESS) {
 123       *error = ErrorUtils::FormatErrorMessageUTF16(
 124           merrors::kInvalidURLHandlerPatternElement, handler_id);
 125       return false;
 126     }
 127     handler.patterns.AddPattern(pattern);
 128   }
 129
 130   url_handlers->push_back(handler);
 131
 132   return true;
 133 }
 134
 135 bool UrlHandlersParser::Parse(Extension* extension, base::string16* error) {
 136   scoped_ptr<UrlHandlers> info(new UrlHandlers);
 137   const base::DictionaryValue* all_handlers = NULL;
 138   if (!extension->manifest()->GetDictionary(
 139         mkeys::kUrlHandlers, &all_handlers)) {
 140     *error = base::ASCIIToUTF16(merrors::kInvalidURLHandlers);
 141     return false;
 142   }
 143
 144   DCHECK(extension->is_platform_app());
 145
 146   for (base::DictionaryValue::Iterator iter(*all_handlers); !iter.IsAtEnd();
 147        iter.Advance()) {
 148     // A URL handler entry is a title and a list of URL patterns to handle.
 149     const base::DictionaryValue* handler = NULL;
 150     if (!iter.value().GetAsDictionary(&handler)) {
 151       *error = base::ASCIIToUTF16(merrors::kInvalidURLHandlerPatternElement);
 152       return false;
 153     }
 154
 155     if (!ParseUrlHandler(iter.key(), *handler, &info->handlers, error)) {
 156       // Text in |error| is set by ParseUrlHandler.
 157       return false;
 158     }
 159   }
 160
 161   extension->SetManifestData(mkeys::kUrlHandlers, info.release());
 162
 163   return true;
 164 }
 165
 166 const std::vector<std::string> UrlHandlersParser::Keys() const {
 167   return SingleKey(mkeys::kUrlHandlers);
 168 }
 169
 170 }  // namespace extensions