Certificate Transparency: Adding finch and NetLog logging for EV certs

chrome/browser/component_updater/ev_whitelist_component_installer.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 "chrome/browser/component_updater/ev_whitelist_component_installer.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 
 namespace {
 const base::FilePath::CharType kCompressedEVWhitelistFileName[] =
     FILE_PATH_LITERAL("ev_hashes_whitelist.bin");
 
 base::FilePath GetEVWhitelistFilePath(const base::FilePath& base_path) {
   return base_path.Append(kCompressedEVWhitelistFileName);
 }
 
 void UpdateNewWhitelistData(const base::FilePath& new_whitelist_file,
-                            const base::FilePath& stored_whitelist_path) {
+                            const base::FilePath& stored_whitelist_path,
+                            const base::Version& version) {
   VLOG(1) << "Reading new EV whitelist from file: "
           << new_whitelist_file.value();
   std::string compressed_list;
   if (!base::ReadFileToString(new_whitelist_file, &compressed_list)) {
     VLOG(1) << "Failed reading from " << new_whitelist_file.value();
     return;
   }
 
   scoped_refptr<net::ct::EVCertsWhitelist> new_whitelist(
-      new PackedEVCertsWhitelist(compressed_list));
+      new PackedEVCertsWhitelist(compressed_list, version));
   if (!new_whitelist->IsValid()) {
     VLOG(1) << "Failed uncompressing EV certs whitelist.";
     return;
   }
 
   if (base::IsValueInRangeForNumericType<int>(compressed_list.size())) {
     const int list_size = base::checked_cast<int>(compressed_list.size());
     if (base::WriteFile(stored_whitelist_path, compressed_list.data(),
                         list_size) != list_size) {
       LOG(WARNING) << "Failed to save new EV whitelist to file.";
     }
   }
 
   SetEVCertsWhitelist(new_whitelist);
 }
 
 void DoInitialLoadFromDisk(const base::FilePath& stored_whitelist_path) {
   if (stored_whitelist_path.empty()) {
     return;
   }
 
   VLOG(1) << "Initial load: reading EV whitelist from file: "
           << stored_whitelist_path.value();
   std::string compressed_list;
   if (!base::ReadFileToString(stored_whitelist_path, &compressed_list)) {
     VLOG(1) << "Failed reading from " << stored_whitelist_path.value();
     return;
   }
 
+  // The version number is unknown as the list is loaded from disk, not
+  // the component.
+  // In practice very quickly the component updater will call ComponentReady
+  // which will have a valid version.
   scoped_refptr<net::ct::EVCertsWhitelist> new_whitelist(
-      new PackedEVCertsWhitelist(compressed_list));
+      new PackedEVCertsWhitelist(compressed_list, Version()));
   if (!new_whitelist->IsValid()) {
     VLOG(1) << "Failed uncompressing EV certs whitelist.";
     return;
   }
 
   VLOG(1) << "EV whitelist: Sucessfully loaded initial data.";
   SetEVCertsWhitelist(new_whitelist);
 }
 
 }  // namespace
@@ skipping 36 matching lines @@
 
 void EVWhitelistComponentInstallerTraits::ComponentReady(
     const base::Version& version,
     const base::FilePath& path,
     scoped_ptr<base::DictionaryValue> manifest) {
   VLOG(1) << "Component ready, version " << version.GetString() << " in "
           << path.value();
 
   const base::FilePath whitelist_file = GetInstalledPath(path);
   content::BrowserThread::PostBlockingPoolTask(
-      FROM_HERE,
-      base::Bind(&UpdateNewWhitelistData, whitelist_file, ev_whitelist_path_));
+      FROM_HERE, base::Bind(&UpdateNewWhitelistData, whitelist_file,
+                            ev_whitelist_path_, version));
 }
 
 bool EVWhitelistComponentInstallerTraits::VerifyInstallation(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_dir) const {
   const base::FilePath expected_file = GetInstalledPath(install_dir);
   VLOG(1) << "Verifying install: " << expected_file.value();
   if (!base::PathExists(expected_file)) {
     VLOG(1) << "File missing.";
     return false;
@@ skipping 38 matching lines @@
   installer->Register(cus);
 
   if (!content::BrowserThread::PostBlockingPoolTask(
           FROM_HERE,
           base::Bind(&DoInitialLoadFromDisk, GetEVWhitelistFilePath(path)))) {
     NOTREACHED();
   }
 }
 
 }  // namespace component_updater