Suffixed histograms for SB2.DatabaseKilobytes and SB2.PrefixSetKilobytes

chrome/browser/safe_browsing/safe_browsing_database.cc

 // Copyright (c) 2012 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 "chrome/browser/safe_browsing/safe_browsing_database.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/process/process_handle.h"
 #include "base/process/process_metrics.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/safe_browsing/prefix_set.h"
 #include "chrome/browser/safe_browsing/safe_browsing_store_file.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/sha2.h"
 #include "net/base/net_util.h"
 #include "url/gurl.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif
 
 using content::BrowserThread;
 using safe_browsing::PrefixSet;
 using safe_browsing::PrefixSetBuilder;
 
 namespace {
 
 // Filename suffix for the bloom filter.
-const base::FilePath::CharType kBloomFilterFile[] =
+const base::FilePath::CharType kBloomFilterFileSuffix[] =
     FILE_PATH_LITERAL(" Filter 2");
 // Filename suffix for the prefix set.
-const base::FilePath::CharType kPrefixSetFile[] =
+const base::FilePath::CharType kPrefixSetFileSuffix[] =
     FILE_PATH_LITERAL(" Prefix Set");
 // Filename suffix for download store.
 const base::FilePath::CharType kDownloadDBFile[] =
     FILE_PATH_LITERAL(" Download");
 // Filename suffix for client-side phishing detection whitelist store.
 const base::FilePath::CharType kCsdWhitelistDBFile[] =
     FILE_PATH_LITERAL(" Csd Whitelist");
 // Filename suffix for the download whitelist store.
 const base::FilePath::CharType kDownloadWhitelistDBFile[] =
     FILE_PATH_LITERAL(" Download Whitelist");
@@ skipping 328 matching lines @@
 
 // static
 base::FilePath SafeBrowsingDatabase::DownloadDBFilename(
     const base::FilePath& db_base_filename) {
   return base::FilePath(db_base_filename.value() + kDownloadDBFile);
 }
 
 // static
 base::FilePath SafeBrowsingDatabase::BloomFilterForFilename(
     const base::FilePath& db_filename) {
-  return base::FilePath(db_filename.value() + kBloomFilterFile);
+  return base::FilePath(db_filename.value() + kBloomFilterFileSuffix);
 }
 
 // static
 base::FilePath SafeBrowsingDatabase::PrefixSetForFilename(
     const base::FilePath& db_filename) {
-  return base::FilePath(db_filename.value() + kPrefixSetFile);
+  return base::FilePath(db_filename.value() + kPrefixSetFileSuffix);
 }
 
 // static
 base::FilePath SafeBrowsingDatabase::CsdWhitelistDBFilename(
     const base::FilePath& db_filename) {
   return base::FilePath(db_filename.value() + kCsdWhitelistDBFile);
 }
 
 // static
 base::FilePath SafeBrowsingDatabase::DownloadWhitelistDBFilename(
@@ skipping 935 matching lines @@
     if (side_effect_free_whitelist_store_)
       side_effect_free_whitelist_store_->CancelUpdate();
     if (ip_blacklist_store_)
       ip_blacklist_store_->CancelUpdate();
     if (unwanted_software_store_)
       unwanted_software_store_->CancelUpdate();
     return;
   }
 
   if (download_store_) {
-    int64 size_bytes = UpdateHashPrefixStore(
-        DownloadDBFilename(filename_base_),
-        download_store_.get(),
-        FAILURE_DOWNLOAD_DATABASE_UPDATE_FINISH);
-    UMA_HISTOGRAM_COUNTS("SB2.DownloadDatabaseKilobytes",
-                         static_cast<int>(size_bytes / 1024));
+    UpdateHashPrefixStore(DownloadDBFilename(filename_base_),
+                          download_store_.get(),
+                          FAILURE_DOWNLOAD_DATABASE_UPDATE_FINISH);
   }
 
   UpdatePrefixSetUrlStore(BrowseDBFilename(filename_base_),
                           browse_store_.get(),
                           PrefixSetId::BROWSE,
                           FAILURE_BROWSE_DATABASE_UPDATE_FINISH,
                           FAILURE_BROWSE_PREFIX_SET_WRITE,
                           true);
 
   UpdateWhitelistStore(CsdWhitelistDBFilename(filename_base_),
                        csd_whitelist_store_.get(),
                        SBWhitelistId::CSD);
   UpdateWhitelistStore(DownloadWhitelistDBFilename(filename_base_),
                        download_whitelist_store_.get(),
                        SBWhitelistId::DOWNLOAD);
 
   if (extension_blacklist_store_) {
-    int64 size_bytes = UpdateHashPrefixStore(
-        ExtensionBlacklistDBFilename(filename_base_),
-        extension_blacklist_store_.get(),
-        FAILURE_EXTENSION_BLACKLIST_UPDATE_FINISH);
-    UMA_HISTOGRAM_COUNTS("SB2.ExtensionBlacklistKilobytes",
-                         static_cast<int>(size_bytes / 1024));
+    UpdateHashPrefixStore(ExtensionBlacklistDBFilename(filename_base_),
+                          extension_blacklist_store_.get(),
+                          FAILURE_EXTENSION_BLACKLIST_UPDATE_FINISH);
   }
 
   if (side_effect_free_whitelist_store_) {
     UpdatePrefixSetUrlStore(SideEffectFreeWhitelistDBFilename(filename_base_),
                             side_effect_free_whitelist_store_.get(),
                             PrefixSetId::SIDE_EFFECT_FREE_WHITELIST,
                             FAILURE_SIDE_EFFECT_FREE_WHITELIST_UPDATE_FINISH,
                             FAILURE_SIDE_EFFECT_FREE_WHITELIST_PREFIX_SET_WRITE,
                             false);
   }
@@ skipping 23 matching lines @@
   // Note: |builder| will not be empty.  The current data store implementation
   // stores all full-length hashes as both full and prefix hashes.
   PrefixSetBuilder builder;
   std::vector<SBAddFullHash> full_hashes;
   if (!store->FinishUpdate(&builder, &full_hashes)) {
     RecordFailure(FAILURE_WHITELIST_DATABASE_UPDATE_FINISH);
     state_manager_.BeginWriteTransaction()->WhitelistEverything(whitelist_id);
     return;
   }
 
+  RecordFileSizeHistogram(store_filename);
+
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(store_filename);
 #endif
 
   LoadWhitelist(full_hashes, whitelist_id);
 }
 
-int64 SafeBrowsingDatabaseNew::UpdateHashPrefixStore(
+void SafeBrowsingDatabaseNew::UpdateHashPrefixStore(
     const base::FilePath& store_filename,
     SafeBrowsingStore* store,
     FailureType failure_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // These results are not used after this call. Simply ignore the
   // returned value after FinishUpdate(...).
   PrefixSetBuilder builder;
   std::vector<SBAddFullHash> add_full_hashes_result;
 
   if (!store->FinishUpdate(&builder, &add_full_hashes_result))
     RecordFailure(failure_type);
 
+  RecordFileSizeHistogram(store_filename);
+
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(store_filename);
 #endif
-
-  return GetFileSizeOrZero(store_filename);
 }
 
 void SafeBrowsingDatabaseNew::UpdatePrefixSetUrlStore(
     const base::FilePath& db_filename,
     SafeBrowsingStore* url_store,
     PrefixSetId prefix_set_id,
     FailureType finish_failure_type,
     FailureType write_failure_type,
     bool store_full_hashes_in_prefix_set) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 43 matching lines @@
     // here.
     new_prefix_set = builder.GetPrefixSetNoHashes();
   }
 
   // Swap in the newly built filter.
   state_manager_.BeginWriteTransaction()->SwapPrefixSet(prefix_set_id,
                                                         new_prefix_set.Pass());
 
   UMA_HISTOGRAM_LONG_TIMES("SB2.BuildFilter", base::TimeTicks::Now() - before);
 
-  {
-    // Persist the prefix set to disk. Do not grab the lock to avoid contention
-    // while writing to disk. This is safe as only this thread can ever modify
-    // |state_manager_|'s prefix sets anyways.
-    scoped_ptr<ReadTransaction> txn =
-        state_manager_.BeginReadTransactionNoLockOnMainThread();
-    WritePrefixSet(db_filename, txn->GetPrefixSet(prefix_set_id),
-                   write_failure_type);
-  }
+  WritePrefixSet(db_filename, prefix_set_id, write_failure_type);
 
   // Gather statistics.
   if (got_counters && metric->GetIOCounters(&io_after)) {
     UMA_HISTOGRAM_COUNTS("SB2.BuildReadKilobytes",
                          static_cast<int>(io_after.ReadTransferCount -
                                           io_before.ReadTransferCount) / 1024);
     UMA_HISTOGRAM_COUNTS("SB2.BuildWriteKilobytes",
                          static_cast<int>(io_after.WriteTransferCount -
                                           io_before.WriteTransferCount) / 1024);
     UMA_HISTOGRAM_COUNTS("SB2.BuildReadOperations",
                          static_cast<int>(io_after.ReadOperationCount -
                                           io_before.ReadOperationCount));
     UMA_HISTOGRAM_COUNTS("SB2.BuildWriteOperations",
                          static_cast<int>(io_after.WriteOperationCount -
                                           io_before.WriteOperationCount));
   }
 
-  const int64 file_size = GetFileSizeOrZero(db_filename);
-  UMA_HISTOGRAM_COUNTS("SB2.DatabaseKilobytes",
-                       static_cast<int>(file_size / 1024));
+  RecordFileSizeHistogram(db_filename);
 
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(db_filename);
 #endif
 }
 
 void SafeBrowsingDatabaseNew::UpdateIpBlacklistStore() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note: prefixes will not be empty.  The current data store implementation
   // stores all full-length hashes as both full and prefix hashes.
   PrefixSetBuilder builder;
   std::vector<SBAddFullHash> full_hashes;
   if (!ip_blacklist_store_->FinishUpdate(&builder, &full_hashes)) {
     RecordFailure(FAILURE_IP_BLACKLIST_UPDATE_FINISH);
     LoadIpBlacklist(std::vector<SBAddFullHash>());  // Clear the list.
     return;
   }
 
+  const base::FilePath ip_blacklist_filename =
+      IpBlacklistDBFilename(filename_base_);
+
+  RecordFileSizeHistogram(ip_blacklist_filename);
+
 #if defined(OS_MACOSX)
-  base::mac::SetFileBackupExclusion(IpBlacklistDBFilename(filename_base_));
+  base::mac::SetFileBackupExclusion(ip_blacklist_filename);
 #endif
 
   LoadIpBlacklist(full_hashes);
 }
 
 void SafeBrowsingDatabaseNew::HandleCorruptDatabase() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Reset the database after the current task has unwound (but only
   // reset once within the scope of a given task).
@@ skipping 122 matching lines @@
 
   const bool r11 =
       base::DeleteFile(UnwantedSoftwareDBFilename(filename_base_), false);
   if (!r11)
     RecordFailure(FAILURE_UNWANTED_SOFTWARE_PREFIX_SET_DELETE);
 
   return r1 && r2 && r3 && r4 && r5 && r6 && r7 && r8 && r9 && r10 && r11;
 }
 
 void SafeBrowsingDatabaseNew::WritePrefixSet(const base::FilePath& db_filename,
-                                             const PrefixSet* prefix_set,
+                                             PrefixSetId prefix_set_id,
                                              FailureType write_failure_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  // Do not grab the lock to avoid contention while writing to disk. This is
+  // safe as only this thread can ever modify |state_manager_|'s prefix sets
+  // anyways.
+  scoped_ptr<ReadTransaction> txn =
+      state_manager_.BeginReadTransactionNoLockOnMainThread();
+  const PrefixSet* prefix_set = txn->GetPrefixSet(prefix_set_id);
+
   if (!prefix_set)
     return;
 
   const base::FilePath prefix_set_filename = PrefixSetForFilename(db_filename);
 
   const base::TimeTicks before = base::TimeTicks::Now();
   const bool write_ok = prefix_set->WriteFile(prefix_set_filename);
   UMA_HISTOGRAM_TIMES("SB2.PrefixSetWrite", base::TimeTicks::Now() - before);
 
-  const int64 file_size = GetFileSizeOrZero(prefix_set_filename);
-  UMA_HISTOGRAM_COUNTS("SB2.PrefixSetKilobytes",
-                       static_cast<int>(file_size / 1024));
+  RecordFileSizeHistogram(prefix_set_filename);
 
   if (!write_ok)
     RecordFailure(write_failure_type);
 
 #if defined(OS_MACOSX)
   base::mac::SetFileBackupExclusion(prefix_set_filename);
 #endif
 }
 
 void SafeBrowsingDatabaseNew::LoadWhitelist(
@@ skipping 75 matching lines @@
 bool SafeBrowsingDatabaseNew::IsCsdWhitelistKillSwitchOn() {
   return state_manager_.BeginReadTransaction()
       ->GetSBWhitelist(SBWhitelistId::CSD)
       ->second;
 }
 
 SafeBrowsingDatabaseNew::PrefixGetHashCache*
 SafeBrowsingDatabaseNew::GetUnsynchronizedPrefixGetHashCacheForTesting() {
   return state_manager_.BeginReadTransaction()->prefix_gethash_cache();
 }
+
+void SafeBrowsingDatabaseNew::RecordFileSizeHistogram(
+    const base::FilePath& file_path) {
+  const int64 file_size = GetFileSizeOrZero(file_path);
+  const int file_size_kilobytes = static_cast<int>(file_size / 1024);
+
+  base::FilePath::StringType filename = file_path.BaseName().value();
+
+  // Default to logging DB sizes unless |file_path| points at PrefixSet storage.
+  std::string histogram_name("SB2.DatabaseKilobytes");
+  if (EndsWith(filename, kPrefixSetFileSuffix, true)) {
+    histogram_name = "SB2.PrefixSetKilobytes";
+    // Clear the PrefixSet suffix to have the histogram suffix selector below
+    // work the same for PrefixSet-based storage as it does for simple safe
+    // browsing stores.
+    // The size of the kPrefixSetFileSuffix is the size of its array minus 1 as
+    // the array includes the terminating '\0'.
+    const size_t kPrefixSetSuffixSize = arraysize(kPrefixSetFileSuffix) - 1;
+    filename.erase(filename.size() - kPrefixSetSuffixSize);
+  }
+
+  // Changes to histogram suffixes below need to be mirrored in the
+  // SafeBrowsingLists suffix enum in histograms.xml.
+  if (EndsWith(filename, kBrowseDBFile, true))
+    histogram_name.append(".Browse");
+  else if (EndsWith(filename, kDownloadDBFile, true))
+    histogram_name.append(".Download");
+  else if (EndsWith(filename, kCsdWhitelistDBFile, true))
+    histogram_name.append(".CsdWhitelist");
+  else if (EndsWith(filename, kDownloadWhitelistDBFile, true))
+    histogram_name.append(".DownloadWhitelist");
+  else if (EndsWith(filename, kExtensionBlacklistDBFile, true))
+    histogram_name.append(".ExtensionBlacklist");
+  else if (EndsWith(filename, kSideEffectFreeWhitelistDBFile, true))
+    histogram_name.append(".SideEffectFreeWhitelist");
+  else if (EndsWith(filename, kIPBlacklistDBFile, true))
+    histogram_name.append(".IPBlacklist");
+  else if (EndsWith(filename, kUnwantedSoftwareDBFile, true))
+    histogram_name.append(".UnwantedSoftware");
+  else
+    NOTREACHED();  // Add support for new lists above.
+
+  // Histogram properties as in UMA_HISTOGRAM_COUNTS macro.
+  base::HistogramBase* histogram_pointer = base::Histogram::FactoryGet(
+      histogram_name, 1, 1000000, 50,
+      base::HistogramBase::kUmaTargetedHistogramFlag);
+
+  histogram_pointer->Add(file_size_kilobytes);
+}