Fix extension content verification handling of ./ in icon 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 {
@@ skipping 79 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);
   }
 }
 
+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(JoinString(parts, '/'));
+}
+
 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));
+    }
+
     scoped_ptr<ContentVerifierIOData::ExtensionData> data(
         new ContentVerifierIOData::ExtensionData(
-            delegate_->GetBrowserImagePaths(extension),
+            image_paths.Pass(),
             extension->version() ? *extension->version() : base::Version()));
     content::BrowserThread::PostTask(content::BrowserThread::IO,
                                      FROM_HERE,
                                      base::Bind(&ContentVerifierIOData::AddData,
                                                 io_data_,
                                                 extension->id(),
                                                 base::Passed(&data)));
     fetcher_->ExtensionLoaded(extension);
   }
 }
@@ skipping 58 matching lines @@
 bool ContentVerifier::ShouldVerifyAnyPaths(
     const std::string& extension_id,
     const base::FilePath& extension_root,
     const std::set<base::FilePath>& relative_paths) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   const ContentVerifierIOData::ExtensionData* data =
       io_data_->GetData(extension_id);
   if (!data)
     return false;
 
-  const std::set<base::FilePath>& browser_images = data->browser_image_paths;
+  const std::set<base::FilePath>& browser_images = *(data->browser_image_paths);
 
   base::FilePath locales_dir = extension_root.Append(kLocaleFolder);
   scoped_ptr<std::set<std::string> > all_locales;
 
   for (std::set<base::FilePath>::const_iterator i = relative_paths.begin();
        i != relative_paths.end();
        ++i) {
     const base::FilePath& relative_path = *i;
 
     if (relative_path == base::FilePath(kManifestFilename))
@@ skipping 19 matching lines @@
           !extension_l10n_util::ShouldSkipValidation(
               locales_dir, full_path.DirName(), *all_locales))
         continue;
     }
     return true;
   }
   return false;
 }
 
 }  // namespace extensions