Only whitelist messages.json files in _locales for content verification

extensions/browser/content_hash_fetcher.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_hash_fetcher.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 218 matching lines @@
       LOG(WARNING) << "Failed to delete " << path.value();
     return false;
   }
   return true;
 }
 
 void ContentHashFetcherJob::DoneCheckingForVerifiedContents(bool found) {
   if (IsCancelled())
     return;
   if (found) {
-    VLOG(1) << "Found verified contents for " << extension_id_;
+    LOG(WARNING) << "Found verified contents for " << extension_id_;
     DoneFetchingVerifiedContents(true);
   } else {
-    VLOG(1) << "Missing verified contents for " << extension_id_
-            << ", fetching...";
+    LOG(WARNING) << "Missing verified contents for " << extension_id_
+                 << ", fetching...";
     url_fetcher_ =
         net::URLFetcher::Create(fetch_url_, net::URLFetcher::GET, this);
     url_fetcher_->SetRequestContext(request_context_);
     url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                                net::LOAD_DO_NOT_SAVE_COOKIES |
                                net::LOAD_DISABLE_CACHE);
     url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
     url_fetcher_->Start();
   }
 }
 
 // Helper function to let us pass ownership of a string via base::Bind with the
 // contents to be written into a file. Also ensures that the directory for
 // |path| exists, creating it if needed.
 static int WriteFileHelper(const base::FilePath& path,
                            std::unique_ptr<std::string> content) {
   base::FilePath dir = path.DirName();
   if (!base::CreateDirectoryAndGetError(dir, nullptr))
     return -1;
   return base::WriteFile(path, content->data(), content->size());
 }
 
 void ContentHashFetcherJob::OnURLFetchComplete(const net::URLFetcher* source) {
-  VLOG(1) << "URLFetchComplete for " << extension_id_
-          << " is_success:" << url_fetcher_->GetStatus().is_success() << " "
-          << fetch_url_.possibly_invalid_spec();
+  LOG(WARNING) << "URLFetchComplete for " << extension_id_
+               << " is_success:" << url_fetcher_->GetStatus().is_success()
+               << " " << fetch_url_.possibly_invalid_spec();
   if (IsCancelled())
     return;
   std::unique_ptr<std::string> response(new std::string);
   if (!url_fetcher_->GetStatus().is_success() ||
       !url_fetcher_->GetResponseAsString(response.get())) {
     DoneFetchingVerifiedContents(false);
     return;
   }
 
   // Parse the response to make sure it is valid json (on staging sometimes it
   // can be a login redirect html, xml file, etc. if you aren't logged in with
   // the right cookies).  TODO(asargent) - It would be a nice enhancement to
   // move to parsing this in a sandboxed helper (crbug.com/372878).
   std::unique_ptr<base::Value> parsed(base::JSONReader::Read(*response));
   if (parsed) {
-    VLOG(1) << "JSON parsed ok for " << extension_id_;
+    LOG(WARNING) << "JSON parsed ok for " << extension_id_;
 
     parsed.reset();  // no longer needed
     base::FilePath destination =
         file_util::GetVerifiedContentsPath(extension_path_);
     size_t size = response->size();
     base::PostTaskAndReplyWithResult(
         content::BrowserThread::GetBlockingPool(),
         FROM_HERE,
         base::Bind(&WriteFileHelper, destination, base::Passed(&response)),
         base::Bind(
@@ skipping 98 matching lines @@
       continue;
     }
 
     // Iterate through taking the hash of each block of size (block_size_) of
     // the file.
     std::vector<std::string> hashes;
     ComputedHashes::ComputeHashesForContent(contents, block_size_, &hashes);
     std::string root =
         ComputeTreeHashRoot(hashes, block_size_ / crypto::kSHA256Length);
     if (!verified_contents_->TreeHashRootEquals(relative_path, root)) {
-      VLOG(1) << "content mismatch for " << relative_path.AsUTF8Unsafe();
+      LOG(WARNING) << "content mismatch for " << relative_path.AsUTF8Unsafe();
       hash_mismatch_paths_.insert(relative_path);
       continue;
     }
 
     writer.AddHashes(relative_path, block_size_, hashes);
   }
   bool result = writer.WriteToFile(hashes_file);
   UMA_HISTOGRAM_TIMES("ExtensionContentHashFetcher.CreateHashesTime",
                       timer.Elapsed());
   return result;
@@ skipping 83 matching lines @@
 
   for (JobMap::iterator i = jobs_.begin(); i != jobs_.end(); ++i) {
     if (i->second.get() == job) {
       jobs_.erase(i);
       break;
     }
   }
 }
 
 }  // namespace extensions