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.
   V4Store(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-          const base::FilePath& store_path);
+          const base::FilePath& store_path,
+          const uint64_t old_file_size = 0);

[Nathan Parker, 2016/10/24 20:33:55]

I'm not clear on why you need the old_file_size. Every store will have a size
either from reading from disk, or writing to disk. Ya?

[vakh (use Gerrit instead), 2016/10/24 21:32:41]

Yes, except what do we want to report if the update succeeds in memory, but
writing the file to disk fails.
When we get an update, we write it to disk and if that happens successfully, we
set file_size_ = written.

Now imagine the case of being unable to write the new file to disk.
We could set file_size_ to '0' in this case and be done with it. However, IMO,
that would be wrong.

What we are interested in is the size of the store on disk. If the new file
fails to be written, the old file is still there. So, we can inherit the size of
the old file from the old_store and update it if the write to disk occurs
successfully. That's why we need this parameter.

   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.
+  uint64_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.
+  uint64_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_