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

components/safe_browsing_db/v4_store_unittest.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/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 117 matching lines @@
 }
 
 TEST_F(V4StoreTest, TestReadFromNoHashPrefixesFile) {
   ListUpdateResponse list_update_response;
   list_update_response.set_platform_type(LINUX_PLATFORM);
   list_update_response.set_response_type(ListUpdateResponse::FULL_UPDATE);
   WriteFileFormatProtoToFile(0x600D71FE, 9, &list_update_response);
   V4Store store(task_runner_, store_path_);
   EXPECT_EQ(READ_SUCCESS, store.ReadFromDisk());
   EXPECT_TRUE(store.hash_prefix_map_.empty());
+  EXPECT_EQ(14l, store.file_size_);

[Nathan Parker, 2016/10/25 19:01:44]

Is there a case where it should eq 0, like on a failed read from disk?

[vakh (use Gerrit instead), 2016/10/25 19:12:34]

Done.

 }
 
 TEST_F(V4StoreTest, TestAddUnlumpedHashesWithInvalidAddition) {
   HashPrefixMap prefix_map;
   EXPECT_EQ(ADDITIONS_SIZE_UNEXPECTED_FAILURE,
             V4Store::AddUnlumpedHashes(5, "a", &prefix_map));
   EXPECT_TRUE(prefix_map.empty());
 }
 
 TEST_F(V4StoreTest, TestAddUnlumpedHashesWithEmptyString) {
@@ skipping 407 matching lines @@
   EXPECT_FALSE(base::PathExists(write_store.store_path_));
   EXPECT_EQ(WRITE_SUCCESS, write_store.WriteToDisk(Checksum()));
   EXPECT_TRUE(base::PathExists(write_store.store_path_));
 
   V4Store read_store (task_runner_, store_path_);
   EXPECT_EQ(READ_SUCCESS, read_store.ReadFromDisk());
   EXPECT_EQ("test_client_state", read_store.state_);
   ASSERT_EQ(2u, read_store.hash_prefix_map_.size());
   EXPECT_EQ("00000abc", read_store.hash_prefix_map_[4]);
   EXPECT_EQ("00000abcde", read_store.hash_prefix_map_[5]);
+  EXPECT_EQ(71l, read_store.file_size_);
 }
 
 // This tests fails to read the prefix map from the disk because the file on
 // disk is invalid. The hash prefixes string is 6 bytes long, but the prefix
 // size is 5 so the parser isn't able to split the hash prefixes list
 // completely.
 TEST_F(V4StoreTest, TestReadFullResponseWithInvalidHashPrefixMap) {
   V4Store write_store(task_runner_, store_path_);
   write_store.hash_prefix_map_[5] = "abcdef";
   write_store.state_ = "test_client_state";
@@ skipping 201 matching lines @@
   list_update_response.set_new_client_state("test_client_state");
   list_update_response.set_platform_type(LINUX_PLATFORM);
   list_update_response.set_response_type(ListUpdateResponse::FULL_UPDATE);
   list_update_response.mutable_checksum()->set_sha256(
       std::string(crypto::kSHA256Length, 0));
   WriteFileFormatProtoToFile(0x600D71FE, 9, &list_update_response);
   V4Store store(task_runner_, store_path_);
   EXPECT_TRUE(store.expected_checksum_.empty());
   EXPECT_EQ(READ_SUCCESS, store.ReadFromDisk());
   EXPECT_TRUE(!store.expected_checksum_.empty());
+  EXPECT_EQ(69l, store.file_size_);
   EXPECT_EQ("test_client_state", store.state());
 
   EXPECT_FALSE(store.VerifyChecksum());
 
   // Now the case of checksum matching after reading from disk.
   // Proof of checksum mismatch using python:
   // >>> import hashlib
   // >>> m = hashlib.sha256()
   // >>> m.update("abcde")
   // >>> import base64
   // >>> encoded = base64.b64encode(m.digest())
   // >>> encoded
   // 'NrvlDtloQdEEQ7y2cNZVTwo0t2G+Z+ycSorSwMRMpCw='
   std::string expected_checksum;
   base::Base64Decode("NrvlDtloQdEEQ7y2cNZVTwo0t2G+Z+ycSorSwMRMpCw=",
                      &expected_checksum);
   ThreatEntrySet* additions = list_update_response.add_additions();
   additions->set_compression_type(RAW);
   additions->mutable_raw_hashes()->set_prefix_size(5);
   additions->mutable_raw_hashes()->set_raw_hashes("abcde");
   list_update_response.mutable_checksum()->set_sha256(expected_checksum);
   WriteFileFormatProtoToFile(0x600D71FE, 9, &list_update_response);
   V4Store another_store(task_runner_, store_path_);
   EXPECT_TRUE(another_store.expected_checksum_.empty());
 
   EXPECT_EQ(READ_SUCCESS, another_store.ReadFromDisk());
   EXPECT_TRUE(!another_store.expected_checksum_.empty());
   EXPECT_EQ("test_client_state", another_store.state());
+  EXPECT_EQ(69l, store.file_size_);
 
   EXPECT_TRUE(another_store.VerifyChecksum());
 }
 
 TEST_F(V4StoreTest, WriteToDiskFails) {
   // Pass the directory name as file name so that when the code tries to rename
   // the temp store file to |store_path_| it fails.
   EXPECT_EQ(UNABLE_TO_RENAME_FAILURE,
             V4Store(task_runner_, temp_dir_.GetPath()).WriteToDisk(Checksum()));
 }
@@ skipping 18 matching lines @@
   task_runner_->RunPendingTasks();
   base::RunLoop().RunUntilIdle();
 
   // This ensures that the callback was called.
   EXPECT_TRUE(called_back);
   // Ensure that the file is still not created.
   EXPECT_FALSE(base::PathExists(store.store_path_));
 }
 
 }  // namespace safe_browsing