Fix case-sensitivity problems in extension content verification

extensions/browser/verified_contents.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/verified_contents.h"
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/strings/string_util.h"
@@ skipping 168 matching lines @@
       std::string encoded_root_hash;
       std::string root_hash;
       if (!data->GetString(kPathKey, &file_path_string) ||
           !base::IsStringUTF8(file_path_string) ||
           !data->GetString(kRootHashKey, &encoded_root_hash) ||
           !FixupBase64Encoding(&encoded_root_hash) ||
           !base::Base64Decode(encoded_root_hash, &root_hash))
         return false;
       base::FilePath file_path =
           base::FilePath::FromUTF8Unsafe(file_path_string);
-      root_hashes_[file_path] = std::string();
-      root_hashes_[file_path].swap(root_hash);
+      RootHashes::iterator i = root_hashes_.insert(std::make_pair(
+          base::StringToLowerASCII(file_path.value()), std::string()));
+      i->second.swap(root_hash);
     }
 
     break;
   }
   return true;
 }
 
+bool VerifiedContents::HasTreeHashRoot(
+    const base::FilePath& relative_path) const {
+  base::FilePath::StringType path = base::StringToLowerASCII(
+      relative_path.NormalizePathSeparatorsTo('/').value());
+  return root_hashes_.find(path) != root_hashes_.end();
+}
+
+bool VerifiedContents::TreeHashRootEquals(const base::FilePath& relative_path,
+                                          const std::string& expected) const {
+  base::FilePath::StringType path = base::StringToLowerASCII(
+      relative_path.NormalizePathSeparatorsTo('/').value());
+  for (RootHashes::const_iterator i = root_hashes_.find(path);
+       i != root_hashes_.end();
+       ++i) {
+    if (expected == i->second)
+      return true;
+  }
+  return false;
+}
+
+#if 0
 const std::string* VerifiedContents::GetTreeHashRoot(

[Ken Rockot(use gerrit already), 2014/09/26 18:48:13]

Do you really want to keep this around for some reason?

[asargent_no_longer_on_chrome, 2014/09/26 18:51:55]

No. 

     const base::FilePath& relative_path) {
-  std::map<base::FilePath, std::string>::const_iterator i =
+  RootHashes::const_iterator i =
       root_hashes_.find(relative_path.NormalizePathSeparatorsTo('/'));
   if (i == root_hashes_.end())
     return NULL;
   return &i->second;
 }
+#endif
 
 // We're loosely following the "JSON Web Signature" draft spec for signing
 // a JSON payload:
 //
 //   http://tools.ietf.org/html/draft-ietf-jose-json-web-signature-26
 //
 // The idea is that you have some JSON that you want to sign, so you
 // base64-encode that and put it as the "payload" field in a containing
 // dictionary. There might be signatures of it done with multiple
 // algorithms/parameters, so the payload is followed by a list of one or more
@@ skipping 120 matching lines @@
       reinterpret_cast<const uint8*>(payload.data()), payload.size());
 
   if (!signature_verifier.VerifyFinal()) {
     VLOG(1) << "Could not verify signature - VerifyFinal failure";
     return false;
   }
   return true;
 }
 
 }  // namespace extensions