Log the size of each of the stores and complete DB on launch and after each

components/safe_browsing_db/v4_store.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_SAFE_BROWSING_DB_V4_STORE_H_
 #define COMPONENTS_SAFE_BROWSING_DB_V4_STORE_H_
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "components/safe_browsing_db/v4_protocol_manager_util.h"
 
 namespace safe_browsing {
 
 class V4Store;
 
-typedef base::Callback<void(std::unique_ptr<V4Store>)>
+typedef base::Callback<void(std::unique_ptr<V4Store> new_store)>
     UpdatedStoreReadyCallback;
 
 // The sorted list of hash prefixes.
 typedef std::string HashPrefixes;
 
 // Stores the list of sorted hash prefixes, by size.
 // For instance: {4: ["abcd", "bcde", "cdef", "gggg"], 5: ["fffff"]}
 typedef base::hash_map<PrefixSize, HashPrefixes> HashPrefixMap;
 
 // Stores the iterator to the last element merged from the HashPrefixMap for a
@@ skipping 122 matching lines @@
   virtual V4Store* CreateV4Store(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner,
       const base::FilePath& store_path);
 };
 
 class V4Store {
  public:
   // The |task_runner| is used to ensure that the operations in this file are
   // performed on the correct thread. |store_path| specifies the location on
   // disk for this file. The constructor doesn't read the store file from disk.
+  // If the store is being created to apply an update to the old store, then
+  // |old_file_size| is the size of the existing file on disk for this store;
+  // 0 otherwise. This is needed so that we can correctly report the size of
+  // store file on disk, even if writing the new file fails after successfully
+  // applying an update.
   V4Store(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-          const base::FilePath& store_path);
+          const base::FilePath& store_path,
+          const int64_t old_file_size = 0);
   virtual ~V4Store();
 
   const std::string& state() const { return state_; }
 
   const base::FilePath& store_path() const { return store_path_; }
 
   void ApplyUpdate(std::unique_ptr<ListUpdateResponse> response,
-                   const scoped_refptr<base::SingleThreadTaskRunner>&,
-                   UpdatedStoreReadyCallback);
+                   const scoped_refptr<base::SingleThreadTaskRunner>& runner,
+                   UpdatedStoreReadyCallback callback);
+
+  // Records (in kilobytes) and returns the size of the file on disk for this
+  // store using |base_metric| as prefix and the filename as suffix.
+  int64_t RecordAndReturnFileSize(const std::string& base_metric);
 
   // If a hash prefix in this store matches |full_hash|, returns that hash
   // prefix; otherwise returns an empty hash prefix.
   virtual HashPrefix GetMatchingHashPrefix(const FullHash& full_hash);
 
   std::string DebugString() const;
 
   // Schedules the destruction of the V4Store object pointed to by |v4_store|,
   // on the task runner.
   static void Destroy(std::unique_ptr<V4Store> v4_store);
@@ skipping 185 matching lines @@
   // Updates the |additions_map| with the additions received in the partial
   // update from the server. The UMA metrics for all interesting sub-operations
   // use the prefix |metric|.
   ApplyUpdateResult UpdateHashPrefixMapFromAdditions(
       const std::string& metric,
       const ::google::protobuf::RepeatedPtrField<ThreatEntrySet>& additions,
       HashPrefixMap* additions_map);
 
   // Writes the hash_prefix_map_ to disk as a V4StoreFileFormat proto.
   // |checksum| is used to set the |checksum| field in the final proto.
-  StoreWriteResult WriteToDisk(const Checksum& checksum) const;
+  StoreWriteResult WriteToDisk(const Checksum& checksum);
 
   // The checksum value as read from the disk, until it is verified. Once
   // verified, it is cleared.
   std::string expected_checksum_;
 
+  // The size of the file on disk for this store.
+  int64_t file_size_;
+
   // The state of the store as returned by the PVer4 server in the last applied
   // update response.
   std::string state_;
   const base::FilePath store_path_;
   HashPrefixMap hash_prefix_map_;
   const scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
 std::ostream& operator<<(std::ostream& os, const V4Store& store);
 
 }  // namespace safe_browsing
 
 #endif  // COMPONENTS_SAFE_BROWSING_DB_V4_STORE_H_