Move the parsing of "chrome_url_overrides" out of Extension.

chrome/common/extensions/api/url_overrides/url_overrides_handler.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/common/extensions/api/url_overrides/url_overrides_handler.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/string_util.h"
+#include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
+#include "base/values.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/url_constants.h"
+#include "extensions/common/error_utils.h"
+
+namespace keys = extension_manifest_keys;
+namespace errors = extension_manifest_errors;
+
+namespace extensions {
+
+namespace {
+const char kOverrideExtentUrlPatternFormat[] = "chrome://%s/*";
+}  // namespace
+
+// static
+const URLOverridesInfo::URLOverrideMap
+    URLOverridesInfo::GetChromeURLOverrides(const Extension* extension) {

[Yoyo Zhou, 2012/12/28 03:59:45]

This reads somewhat redundantly. Can this Info be combined into the URLInfo from
your other CL?

[Joe Thomas, 2012/12/29 14:44:28]

Yes we can combine, but I think that will increase the size of URLInfo struct.
URLInfo stores data in a GURL object whereas we need a std::map<const
std::string, GURL> to hold the data in URLOverridesInfo. Is it fine to keep both
these objects side-by-side in URLInfo or do you think there is a better way to
do this?

[Yoyo Zhou, 2013/01/03 22:36:03]

As I see it, URLInfo is a general-purpose thing for associating various URLs to
an extension. These are also various URLs that we'd like to associate with an
extension.

I don't necessarily mean that URLInfo should now contain a map of strings->URLs
rather than a single URL as it does now; but since these are related concepts,
it'd make sense to put them together.

[Joe Thomas, 2013/01/04 23:36:11]

Ah Ok. I misunderstood your previous comment. Done.

+  URLOverridesInfo* info = static_cast<URLOverridesInfo*>(
+      extension->GetManifestData(keys::kChromeURLOverrides));
+  if (info)
+    return info->chrome_url_overrides_;
+  return URLOverrideMap();
+}
+
+
+URLOverridesHandler::URLOverridesHandler() {
+}
+
+URLOverridesHandler::~URLOverridesHandler() {
+}
+
+bool URLOverridesHandler::Parse(const base::Value* value,
+                           Extension* extension,
+                           string16* error) {
+  const DictionaryValue* overrides = NULL;
+  if (!value->GetAsDictionary(&overrides)) {
+    *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
+    return false;
+  }
+  scoped_ptr<URLOverridesInfo> info(new URLOverridesInfo);
+  // Validate that the overrides are all strings
+  for (DictionaryValue::key_iterator iter = overrides->begin_keys();
+       iter != overrides->end_keys(); ++iter) {
+    std::string page = *iter;
+    std::string val;
+    // Restrict override pages to a list of supported URLs.
+    bool is_override = (page != chrome::kChromeUINewTabHost &&
+                        page != chrome::kChromeUIBookmarksHost &&
+                        page != chrome::kChromeUIHistoryHost);
+#if defined(OS_CHROMEOS)
+    is_override = (is_override &&
+                   page != chrome::kChromeUIActivationMessageHost);
+#endif
+#if defined(FILE_MANAGER_EXTENSION)
+    is_override = (is_override &&
+                   !(extension->location() == Extension::COMPONENT &&
+                     page == chrome::kChromeUIFileManagerHost));
+#endif
+
+    if (is_override || !overrides->GetStringWithoutPathExpansion(*iter, &val)) {
+      *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
+      return false;
+    }
+    // Replace the entry with a fully qualified chrome-extension:// URL.
+    info->chrome_url_overrides_[page] = extension->GetResourceURL(val);
+
+    // For component extensions, add override URL to extent patterns.
+    if (extension->is_legacy_packaged_app() &&
+        extension->location() == Extension::COMPONENT) {
+      URLPattern pattern(URLPattern::SCHEME_CHROMEUI);
+      std::string url = base::StringPrintf(kOverrideExtentUrlPatternFormat,
+                                           page.c_str());
+      if (pattern.Parse(url) != URLPattern::PARSE_SUCCESS) {
+        *error = ErrorUtils::FormatErrorMessageUTF16(
+            errors::kInvalidURLPatternError, url);
+        return false;
+      }
+      extension->AddWebExtentPattern(pattern);
+    }
+  }
+
+  // An extension may override at most one page.
+  if (overrides->size() > 1) {
+    *error = ASCIIToUTF16(errors::kMultipleOverrides);
+    return false;
+  }
+  extension->SetManifestData(keys::kChromeURLOverrides, info.release());
+  return true;
+}
+
+}  // namespace extensions