Add the about_page key to shared_module manifest

chrome/common/extensions/manifest_url_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/manifest_url_handler.h"
 
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
@@ skipping 67 matching lines @@
     return false;
   return extension_urls::IsWebstoreUpdateUrl(GURL(url));
 }
 
 // static
 const GURL& ManifestURL::GetOptionsPage(const Extension* extension) {
   return GetManifestURL(extension, keys::kOptionsPage);
 }
 
 // static
+const GURL& ManifestURL::GetAboutPage(const Extension* extension) {
+  return GetManifestURL(extension, keys::kOptionsPage);
+}
+
+// static
 const GURL ManifestURL::GetDetailsURL(const Extension* extension) {
   return extension->from_webstore() ?
       GURL(extension_urls::GetWebstoreItemDetailURLPrefix() + extension->id()) :
       GURL::EmptyGURL();
 }
 
 URLOverrides::URLOverrides() {
 }
 
 URLOverrides::~URLOverrides() {
@@ skipping 159 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 const std::vector<std::string> OptionsPageHandler::Keys() const {
   return SingleKey(keys::kOptionsPage);
 }
 
+AboutPageHandler::AboutPageHandler() {

[benwells, 2014/06/05 03:59:17]

This class is so similar to the options page class. I wonder if we could pull
out the commonality into a superclass. What do you think that would look like?

It would mean if we ever found / fixed a bug (e.g. in how we detect if a URL is
absolute) we wouldn't need to do it twice.

[sashab, 2014/06/10 05:44:13]

Not sure if they're _that_ similar. The options_page key allows for an absolute
URL for extensions, but a relative URL for packaged apps. But yes, I agree that
they are very similar.

A lot of it is already method calls, so I'm not sure how much could really be
abstracted out. Also, the error messages are different constants.

If you have any ideas though, let me know. I can also add a TODO.

[benwells, 2014/06/11 00:47:29]

I could imagine a URLManifestHandler, which when overridden you just provided
some fields like whether it is absolute or relative and error strings. But,
whatevs.

+}
+
+AboutPageHandler::~AboutPageHandler() {
+}
+
+bool AboutPageHandler::Parse(Extension* extension, base::string16* error) {
+  scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
+  std::string options_str;

[benwells, 2014/06/05 03:59:17]

Nit: options_str -> about_str

[sashab, 2014/06/10 05:44:13]

Done.

+  if (!extension->manifest()->GetString(keys::kAboutPage, &options_str)) {
+    *error = base::ASCIIToUTF16(errors::kInvalidAboutPage);
+    return false;
+  }
+
+  GURL absolute(options_str);
+  if (absolute.is_valid()) {
+    *error = base::ASCIIToUTF16(errors::kInvalidAboutPageExpectRelativePath);
+    return false;
+  }
+  manifest_url->url_ = extension->GetResourceURL(options_str);
+  if (!manifest_url->url_.is_valid()) {
+    *error = base::ASCIIToUTF16(errors::kInvalidAboutPage);
+    return false;
+  }
+  extension->SetManifestData(keys::kAboutPage, manifest_url.release());
+  return true;
+}
+
+bool AboutPageHandler::Validate(const Extension* extension,
+                                std::string* error,
+                                std::vector<InstallWarning>* warnings) const {
+  // Validate path to the options page.
+  if (!extensions::ManifestURL::GetAboutPage(extension).is_empty()) {
+    const base::FilePath about_path =
+        extensions::file_util::ExtensionURLToRelativeFilePath(
+            extensions::ManifestURL::GetAboutPage(extension));
+    const base::FilePath path =
+        extension->GetResource(about_path).GetFilePath();
+    if (path.empty() || !base::PathExists(path)) {
+      *error = l10n_util::GetStringFUTF8(IDS_EXTENSION_LOAD_ABOUT_PAGE_FAILED,
+                                         about_path.LossyDisplayName());
+      return false;
+    }
+  }
+  return true;
+}
+
+const std::vector<std::string> AboutPageHandler::Keys() const {
+  return SingleKey(keys::kAboutPage);
+}
+
 URLOverridesHandler::URLOverridesHandler() {
 }
 
 URLOverridesHandler::~URLOverridesHandler() {
 }
 
 bool URLOverridesHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* overrides = NULL;
   if (!extension->manifest()->GetDictionary(keys::kChromeURLOverrides,
                                             &overrides)) {
@@ skipping 48 matching lines @@
   extension->SetManifestData(keys::kChromeURLOverrides,
                              url_overrides.release());
   return true;
 }
 
 const std::vector<std::string> URLOverridesHandler::Keys() const {
   return SingleKey(keys::kChromeURLOverrides);
 }
 
 }  // namespace extensions