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 163 matching lines @@
 using ::google::protobuf::int32;
 
 std::ostream& operator<<(std::ostream& os, const V4Store& store) {
   os << store.DebugString();
   return os;
 }
 
 V4Store* V4StoreFactory::CreateV4Store(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     const base::FilePath& store_path) {
-  V4Store* new_store = new V4Store(task_runner, store_path);
+  V4Store* new_store = new V4Store(task_runner, store_path, 0);
   new_store->Initialize();
   return new_store;
 }
 
 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) {}
+                 const base::FilePath& store_path,
+                 const int64_t old_file_size)
+    : file_size_(old_file_size),
+      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 130 matching lines @@
   RecordMergeUpdateTime(metric, TimeTicks::Now() - before, store_path_);
 
   state_ = response->new_client_state();
   return APPLY_UPDATE_SUCCESS;
 }
 
 void V4Store::ApplyUpdate(
     std::unique_ptr<ListUpdateResponse> response,
     const scoped_refptr<base::SingleThreadTaskRunner>& callback_task_runner,
     UpdatedStoreReadyCallback callback) {
-  std::unique_ptr<V4Store> new_store(new V4Store(task_runner_, store_path_));
+  std::unique_ptr<V4Store> new_store(
+      new V4Store(task_runner_, store_path_, file_size_));
   ApplyUpdateResult apply_update_result;
   std::string metric;
   TimeTicks before = TimeTicks::Now();
   if (response->response_type() == ListUpdateResponse::PARTIAL_UPDATE) {
     metric = kProcessPartialUpdate;
     apply_update_result = new_store->ProcessPartialUpdateAndWriteToDisk(
         metric, hash_prefix_map_, std::move(response));
   } else if (response->response_type() == ListUpdateResponse::FULL_UPDATE) {
     metric = kProcessFullUpdate;
     apply_update_result =
@@ skipping 289 matching lines @@
     }
   }
 
   return APPLY_UPDATE_SUCCESS;
 }
 
 StoreReadResult V4Store::ReadFromDisk() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   V4StoreFileFormat file_format;
+  int64_t file_size;
   TimeTicks before = TimeTicks::Now();
   {
     // A temporary scope to make sure that |contents| get destroyed as soon as
     // we are doing using it.
     std::string contents;
     bool read_success = base::ReadFileToString(store_path_, &contents);
     if (!read_success) {
       return FILE_UNREADABLE_FAILURE;
     }
 
     if (contents.empty()) {
       return FILE_EMPTY_FAILURE;
     }
 
     if (!file_format.ParseFromString(contents)) {
       return PROTO_PARSING_FAILURE;
     }
+    file_size = static_cast<int64_t>(contents.size());
   }
 
   if (file_format.magic_number() != kFileMagic) {
     return UNEXPECTED_MAGIC_NUMBER_FAILURE;
   }
 
   UMA_HISTOGRAM_SPARSE_SLOWLY("SafeBrowsing.V4StoreVersionRead",
                               file_format.version_number());
   if (file_format.version_number() != kFileVersion) {
     return FILE_VERSION_INCOMPATIBLE_FAILURE;
   }
 
   if (!file_format.has_list_update_response()) {
     return HASH_PREFIX_INFO_MISSING_FAILURE;
   }
 
   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_);
 
+  // Update |file_size_| now because we parsed the file correctly.
+  file_size_ = file_size;
+
   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;
   }
 
+  // Update |file_size_| now because we wrote the file correctly.
+  file_size_ = static_cast<int64_t>(written);
+
   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;
 }
 
+int64_t 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 int64_t file_size_kilobytes = file_size_ / 1024;
+    histogram->Add(file_size_kilobytes);
+  }
+  return file_size_;
+}
+
 }  // namespace safe_browsing