Fix content verification failures on unusual content script paths

extensions/browser/content_verifier.cc

 // Copyright 2014 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 "extensions/browser/content_verifier.h"
 
 #include <algorithm>
 
 #include "base/files/file_path.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/content_hash_fetcher.h"
 #include "extensions/browser/content_hash_reader.h"
 #include "extensions/browser/content_verifier_delegate.h"
 #include "extensions/browser/content_verifier_io_data.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_l10n_util.h"
 
 namespace extensions {
 
 namespace {
 
 ContentVerifier::TestObserver* g_test_observer = NULL;
 
+// This function converts paths like "//foo/bar", "./foo/bar", and
+// "/foo/bar" to "foo/bar". It also converts path separators to "/".
+base::FilePath NormalizeRelativePath(const base::FilePath& path) {
+  if (path.ReferencesParent())
+    return base::FilePath();
+
+  std::vector<base::FilePath::StringType> parts;
+  path.GetComponents(&parts);
+  if (parts.empty())
+    return base::FilePath();
+
+  // Remove the first component if it is '.' or '/' or '//'.
+  const base::FilePath::StringType separators(
+      base::FilePath::kSeparators, base::FilePath::kSeparatorsLength);
+  if (!parts[0].empty() &&
+      (parts[0] == base::FilePath::kCurrentDirectory ||
+       parts[0].find_first_not_of(separators) == std::string::npos))
+    parts.erase(parts.begin());
+
+  // Note that elsewhere we always normalize path separators to '/' so this
+  // should work for all platforms.
+  return base::FilePath(
+      base::JoinString(parts, base::FilePath::StringType(1, '/')));
+}
+
 }  // namespace
 
 // static
 void ContentVerifier::SetObserverForTests(TestObserver* observer) {
   g_test_observer = observer;
 }
 
 ContentVerifier::ContentVerifier(content::BrowserContext* context,
                                  ContentVerifierDelegate* delegate)
     : shutdown_(false),
@@ skipping 29 matching lines @@
     const std::string& extension_id,
     const base::FilePath& extension_root,
     const base::FilePath& relative_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   const ContentVerifierIOData::ExtensionData* data =
       io_data_->GetData(extension_id);
   if (!data)
     return NULL;
 
+  base::FilePath normalized_path = NormalizeRelativePath(relative_path);
+
   std::set<base::FilePath> paths;
-  paths.insert(relative_path);
+  paths.insert(normalized_path);
   if (!ShouldVerifyAnyPaths(extension_id, extension_root, paths))
     return NULL;
 
   // TODO(asargent) - we can probably get some good performance wins by having
   // a cache of ContentHashReader's that we hold onto past the end of each job.
   return new ContentVerifyJob(
       new ContentHashReader(extension_id, data->version, extension_root,
-                            relative_path, delegate_->GetPublicKey()),
+                            normalized_path, delegate_->GetPublicKey()),
       base::Bind(&ContentVerifier::VerifyFailed, this, extension_id));
 }
 
 void ContentVerifier::VerifyFailed(const std::string& extension_id,
                                    ContentVerifyJob::FailureReason reason) {
   if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
         base::Bind(&ContentVerifier::VerifyFailed, this, extension_id, reason));
@@ skipping 13 matching lines @@
 
   if (reason == ContentVerifyJob::MISSING_ALL_HASHES) {
     // If we failed because there were no hashes yet for this extension, just
     // request some.
     fetcher_->DoFetch(extension, true /* force */);
   } else {
     delegate_->VerifyFailed(extension_id, reason);
   }
 }
 
-static base::FilePath MakeImagePathRelative(const base::FilePath& path) {
-  if (path.ReferencesParent())
-    return base::FilePath();
-
-  std::vector<base::FilePath::StringType> parts;
-  path.GetComponents(&parts);
-  if (parts.empty())
-    return base::FilePath();
-
-  // Remove the first component if it is '.' or '/' or '//'.
-  const base::FilePath::StringType separators(
-      base::FilePath::kSeparators, base::FilePath::kSeparatorsLength);
-  if (!parts[0].empty() &&
-      (parts[0] == base::FilePath::kCurrentDirectory ||
-       parts[0].find_first_not_of(separators) == std::string::npos))
-    parts.erase(parts.begin());
-
-  // Note that elsewhere we always normalize path separators to '/' so this
-  // should work for all platforms.
-  return base::FilePath(
-      base::JoinString(parts, base::FilePath::StringType(1, '/')));
-}
-
 void ContentVerifier::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   if (shutdown_)
     return;
 
   ContentVerifierDelegate::Mode mode = delegate_->ShouldBeVerified(*extension);
   if (mode != ContentVerifierDelegate::NONE) {
     // The browser image paths from the extension may not be relative (eg
     // they might have leading '/' or './'), so we strip those to make
     // comparing to actual relative paths work later on.
     std::set<base::FilePath> original_image_paths =
         delegate_->GetBrowserImagePaths(extension);
 
     scoped_ptr<std::set<base::FilePath>> image_paths(
         new std::set<base::FilePath>);
     for (const auto& path : original_image_paths) {
-      image_paths->insert(MakeImagePathRelative(path));
+      image_paths->insert(NormalizeRelativePath(path));
     }
 
     scoped_ptr<ContentVerifierIOData::ExtensionData> data(
         new ContentVerifierIOData::ExtensionData(
             image_paths.Pass(),
             extension->version() ? *extension->version() : base::Version()));
     content::BrowserThread::PostTask(content::BrowserThread::IO,
                                      FROM_HERE,
                                      base::Bind(&ContentVerifierIOData::AddData,
                                                 io_data_,
@@ skipping 106 matching lines @@
           !extension_l10n_util::ShouldSkipValidation(
               locales_dir, full_path.DirName(), *all_locales))
         continue;
     }
     return true;
   }
   return false;
 }
 
 }  // namespace extensions