Wire NetLog into the TreeStateTracker

components/certificate_transparency/single_tree_tracker.h

 // Copyright 2016 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.
 
 #ifndef COMPONENTS_CERTIFICATE_TRANSPARENCY_SINGLE_TREE_TRACKER_H_
 #define COMPONENTS_CERTIFICATE_TRANSPARENCY_SINGLE_TREE_TRACKER_H_
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/containers/mru_cache.h"
 #include "base/memory/memory_pressure_monitor.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/hash_value.h"
 #include "net/cert/ct_verifier.h"
 #include "net/cert/signed_tree_head.h"
 #include "net/cert/sth_observer.h"
+#include "net/log/net_log_with_source.h"
 
 namespace net {
 
 class CTLogVerifier;
 class X509Certificate;
 
 namespace ct {
 
 struct MerkleAuditProof;
 struct SignedCertificateTimestamp;
@@ skipping 41 matching lines @@
 
     // SCT is known and there's a new-enough STH to check inclusion against.
     // It's in the process of being checked for inclusion.
     SCT_PENDING_INCLUSION_CHECK,
 
     // Inclusion check succeeded.
     SCT_INCLUDED_IN_LOG,
   };
 
   SingleTreeTracker(scoped_refptr<const net::CTLogVerifier> ct_log,
-                    LogDnsClient* dns_client);
+                    LogDnsClient* dns_client,
+                    net::NetLog* net_log);
   ~SingleTreeTracker() override;
 
   // net::ct::CTVerifier::Observer implementation.
 
   // TODO(eranm): Extract CTVerifier::Observer to SCTObserver
   // Performs an inclusion check for the given certificate if the latest
   // STH known for this log is older than sct.timestamp + Maximum Merge Delay,
   // enqueues the SCT for future checking later on.
   // Should only be called with SCTs issued by the log this instance tracks.
   // TODO(eranm): Make sure not to perform any synchronous, blocking operation
@@ skipping 43 matching lines @@
   // * If there was a failure to obtain or validate an inclusion
   //   proof, removes |entry| from the queue of entries to validate.
   //   Future calls to GetLogEntryInclusionStatus() will indicate the entry
   //   has not been observed.
   void OnAuditProofObtained(const EntryToAudit& entry, int net_error);
 
   // Clears entries to reduce memory overhead.
   void OnMemoryPressure(
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level);
 
+  void LogAuditResultToNetLog(const EntryToAudit& entry, bool success);
+
   // Holds the latest STH fetched and verified for this log.
   net::ct::SignedTreeHead verified_sth_;
 
   // The log being tracked.
   scoped_refptr<const net::CTLogVerifier> ct_log_;
 
   // Log entries waiting to be checked for inclusion, or being checked for
   // inclusion, and their state.
   std::map<EntryToAudit, EntryAuditState, OrderByTimestamp> pending_entries_;
 
   // A cache of leaf hashes identifying entries which were checked for
   // inclusion (the key is the Leaf Hash of the log entry).
   // NOTE: The current implementation does not cache failures, so the presence
   // of an entry in |checked_entries_| indicates success.
   // To extend support for caching failures, a success indicator should be
   // added to the EntryAuditResult struct.
   base::MRUCache<net::SHA256HashValue,
                  EntryAuditResult,
                  net::SHA256HashValueLessThan>
       checked_entries_;
 
   LogDnsClient* dns_client_;
 
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 
+  net::NetLogWithSource net_log_;
+
   base::WeakPtrFactory<SingleTreeTracker> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SingleTreeTracker);
 };
 
 }  // namespace certificate_transparency
 
 #endif  // COMPONENTS_CERTIFICATE_TRANSPARENCY_SINGLE_TREE_TRACKER_H_