[Extensions] Validate file existence for chrome url overrides

chrome/common/extensions/chrome_manifest_url_handlers.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/chrome_manifest_url_handlers.h"
 
 #include <memory>
 
+#include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/error_utils.h"
+#include "extensions/common/file_util.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/permissions_parser.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "extensions/common/manifest_url_handlers.h"
 #include "extensions/common/permissions/api_permission.h"
 
 #if defined(USE_AURA)
 #include "ui/keyboard/content/keyboard_constants.h"  // nogncheck
 #endif
@@ skipping 69 matching lines @@
     *error = base::ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
     return false;
   }
   std::unique_ptr<URLOverrides> url_overrides(new URLOverrides);
   // Validate that the overrides are all strings
   for (base::DictionaryValue::Iterator iter(*overrides); !iter.IsAtEnd();
        iter.Advance()) {
     std::string page = iter.key();
     std::string val;
     // Restrict override pages to a list of supported URLs.
-    bool is_override = (page != chrome::kChromeUINewTabHost &&
-                        page != chrome::kChromeUIBookmarksHost &&
-                        page != chrome::kChromeUIHistoryHost);
+    bool is_allowed_host = page == chrome::kChromeUINewTabHost ||
+                           page == chrome::kChromeUIBookmarksHost ||
+                           page == chrome::kChromeUIHistoryHost;
 #if defined(OS_CHROMEOS)
-    is_override =
-        (is_override && page != chrome::kChromeUIActivationMessageHost);
-#endif
-#if defined(OS_CHROMEOS)
-    is_override = (is_override && page != keyboard::kKeyboardHost);
+    is_allowed_host = is_allowed_host ||
+                      page == chrome::kChromeUIActivationMessageHost ||
+                      page == keyboard::kKeyboardHost;
 #endif
 
-    if (is_override || !iter.value().GetAsString(&val)) {
+    if (!is_allowed_host || !iter.value().GetAsString(&val)) {
       *error = base::ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
       return false;
     }
     // Replace the entry with a fully qualified chrome-extension:// URL.
     url_overrides->chrome_url_overrides_[page] = extension->GetResourceURL(val);
 
     // For component extensions, add override URL to extent patterns.
     if (extension->is_legacy_packaged_app() &&
         extension->location() == Manifest::COMPONENT) {
       URLPattern pattern(URLPattern::SCHEME_CHROMEUI);
@@ skipping 11 matching lines @@
   // An extension may override at most one page.
   if (overrides->size() > 1) {
     *error = base::ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
   extension->SetManifestData(keys::kChromeURLOverrides,
                              url_overrides.release());
   return true;
 }
 
+bool URLOverridesHandler::Validate(
+    const Extension* extension,
+    std::string* error,
+    std::vector<InstallWarning>* warnings) const {
+  const URLOverrides::URLOverrideMap& overrides =
+      URLOverrides::GetChromeURLOverrides(extension);
+  if (overrides.empty())
+    return true;
+
+  for (const auto& entry : overrides) {
+    base::FilePath relative_path =
+        file_util::ExtensionURLToRelativeFilePath(entry.second);
+    base::FilePath resource_path =
+        extension->GetResource(relative_path).GetFilePath();
+    if (resource_path.empty() || !base::PathExists(resource_path)) {
+      *error = ErrorUtils::FormatErrorMessage(errors::kFileNotFound,
+                                              relative_path.AsUTF8Unsafe());
+      return false;
+    }
+  }
+  return true;
+}
+
 const std::vector<std::string> URLOverridesHandler::Keys() const {
   return SingleKey(keys::kChromeURLOverrides);
 }
 
 }  // namespace extensions