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

components/safe_browsing_db/v4_store.cc

 // 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.
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 178 matching lines @@
 void V4Store::Initialize() {
   // If a state already exists, don't re-initilize.
   DCHECK(state_.empty());
 
   StoreReadResult store_read_result = ReadFromDisk();
   RecordStoreReadResult(store_read_result);
 }
 
 V4Store::V4Store(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
                  const base::FilePath& store_path)
-    : store_path_(store_path), task_runner_(task_runner) {}
+    : file_size_(0), store_path_(store_path), task_runner_(task_runner) {}
 
 V4Store::~V4Store() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 }
 
 std::string V4Store::DebugString() const {
   std::string state_base64;
   base::Base64Encode(state_, &state_base64);
 
   return base::StringPrintf("path: %" PRIsFP "; state: %s",
@@ skipping 483 matching lines @@
   std::unique_ptr<ListUpdateResponse> response(new ListUpdateResponse);
   response->Swap(file_format.mutable_list_update_response());
   ApplyUpdateResult apply_update_result = ProcessFullUpdate(
       kReadFromDisk, response, true /* delay_checksum check */);
   RecordApplyUpdateResult(kReadFromDisk, apply_update_result, store_path_);
   if (apply_update_result != APPLY_UPDATE_SUCCESS) {
     hash_prefix_map_.clear();
     return HASH_PREFIX_MAP_GENERATION_FAILURE;
   }
   RecordApplyUpdateTime(kReadFromDisk, TimeTicks::Now() - before, store_path_);
+  file_size_ = V4ProtocolManagerUtil::GetFileSizeOrZero(store_path_);

[Scott Hess - ex-Googler, 2016/10/21 23:36:45]

Could you get this from contents.size()?

[vakh (use Gerrit instead), 2016/10/24 19:39:32]

Done.

 
   return READ_SUCCESS;
 }
 
-StoreWriteResult V4Store::WriteToDisk(const Checksum& checksum) const {
+StoreWriteResult V4Store::WriteToDisk(const Checksum& checksum) {
   V4StoreFileFormat file_format;
   ListUpdateResponse* lur = file_format.mutable_list_update_response();
   *(lur->mutable_checksum()) = checksum;
   lur->set_new_client_state(state_);
   lur->set_response_type(ListUpdateResponse::FULL_UPDATE);
   for (auto map_iter : hash_prefix_map_) {
     ThreatEntrySet* additions = lur->add_additions();
     // TODO(vakh): Write RICE encoded hash prefixes on disk. Not doing so
     // currently since it takes a long time to decode them on startup, which
     // blocks resource load. See: http://crbug.com/654819
@@ skipping 10 matching lines @@
   std::string file_format_string;
   file_format.SerializeToString(&file_format_string);
   size_t written = base::WriteFile(new_filename, file_format_string.data(),
                                    file_format_string.size());
   DCHECK_EQ(file_format_string.size(), written);
 
   if (!base::Move(new_filename, store_path_)) {
     return UNABLE_TO_RENAME_FAILURE;
   }
 
+  file_size_ = V4ProtocolManagerUtil::GetFileSizeOrZero(store_path_);

[Scott Hess - ex-Googler, 2016/10/21 23:36:45]

Could this ever be a different value from |written|?

[If not ... then my other comment about file_size_ being an int64_t switches to
being a size_t.]

[vakh (use Gerrit instead), 2016/10/24 19:39:32]

Done.

+
   return WRITE_SUCCESS;
 }
 
 HashPrefix V4Store::GetMatchingHashPrefix(const FullHash& full_hash) {
   // It should never be the case that more than one hash prefixes match a given
   // full hash. However, if that happens, this method returns any one of them.
   // It does not guarantee which one of those will be returned.
   DCHECK_EQ(32u, full_hash.size());
   for (const auto& pair : hash_prefix_map_) {
     const PrefixSize& prefix_size = pair.first;
@@ skipping 77 matching lines @@
       DVLOG(1) << "Failure: Checksum mismatch: calculated: " << checksum_b64
                << "; expected: " << expected_checksum_b64
                << "; store: " << *this;
 #endif
       return false;
     }
   }
   return true;
 }
 
+int V4Store::RecordAndReturnFileSize(const std::string& base_metric) {
+  std::string suffix = GetUmaSuffixForStore(store_path_);
+  // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
+  base::HistogramBase* histogram = base::Histogram::FactoryGet(
+      base_metric + suffix, 1, 1000000, 50,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+  if (histogram) {
+    const int file_size_kilobytes = static_cast<int>(file_size_ / 1024);
+    histogram->Add(file_size_kilobytes);
+  }
+  return file_size_;
+}
+
 }  // namespace safe_browsing