[NOT FOR LANDING] Detailed loading traces

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
+#include "base/trace_event/trace_event.h"
 #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/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"
@@ skipping 211 matching lines @@
 }
 
 // Helper for PrefixSetContainsUrlHashes().  Returns true if an un-expired match
 // for |full_hash| is found in |cache|, with any matches appended to |results|
 // (true can be returned with zero matches).  |expire_base| is used to check the
 // cache lifetime of matches, expired matches will be discarded from |cache|.
 bool GetCachedFullHash(std::map<SBPrefix, SBCachedFullHashResult>* cache,
                        const SBFullHash& full_hash,
                        const base::Time& expire_base,
                        std::vector<SBFullHashResult>* results) {
+  TRACE_EVENT0("toplevel", "SafeBrowsingDatabaseNew::GetCachedFullHash");
+
   // First check if there is a valid cached result for this prefix.
   std::map<SBPrefix, SBCachedFullHashResult>::iterator citer =
       cache->find(full_hash.prefix);
   if (citer == cache->end())
     return false;
 
   // Remove expired entries.
   SBCachedFullHashResult& cached_result = citer->second;
   if (cached_result.expire_after <= expire_base) {
     cache->erase(citer);
@@ skipping 229 matching lines @@
       case PrefixSetId::BROWSE:
         return outer_->browse_prefix_set_.get();
       case PrefixSetId::UNWANTED_SOFTWARE:
         return outer_->unwanted_software_prefix_set_.get();
     }
     NOTREACHED();
     return nullptr;
   }
 
   PrefixGetHashCache* prefix_gethash_cache() {
+    TRACE_EVENT0("toplevel",
+                 "SafeBrowsingDatabaseNew::ThreadSafeStateManager::"
+                 "ReadTransaction::prefix_gethash_cache");
     // The cache is special: it is read/write on all threads. Access to it
     // therefore requires a LOCK'ed transaction (i.e. it can't benefit from
     // DONT_LOCK_ON_MAIN_THREAD).
     DCHECK(transaction_lock_);
     return &outer_->prefix_gethash_cache_;
   }
 
  private:
   // Only ThreadSafeStateManager is allowed to build a ReadTransaction.
   friend class ThreadSafeStateManager;
@@ skipping 100 matching lines @@
 SafeBrowsingDatabaseNew::DatabaseStateManager::DatabaseStateManager(
     const scoped_refptr<const base::SequencedTaskRunner>& db_task_runner)
     : db_task_runner_(db_task_runner),
       corruption_detected_(false),
       change_detected_(false) {}
 
 SafeBrowsingDatabaseNew::DatabaseStateManager::~DatabaseStateManager() {}
 
 scoped_ptr<SafeBrowsingDatabaseNew::ReadTransaction>
 SafeBrowsingDatabaseNew::ThreadSafeStateManager::BeginReadTransaction() {
+  TRACE_EVENT0(
+      "toplevel",
+      "SafeBrowsingDatabaseNew::ThreadSafeStateManager::BeginReadTransaction");
   return make_scoped_ptr(
       new ReadTransaction(this, ReadTransaction::AutoLockRequirement::LOCK));
 }
 
 scoped_ptr<SafeBrowsingDatabaseNew::ReadTransaction> SafeBrowsingDatabaseNew::
     ThreadSafeStateManager::BeginReadTransactionNoLockOnMainTaskRunner() {
   return make_scoped_ptr(new ReadTransaction(
       this,
       ReadTransaction::AutoLockRequirement::DONT_LOCK_ON_MAIN_TASK_RUNNER));
 }
@@ skipping 218 matching lines @@
   txn->clear_ip_blacklist();
   txn->WhitelistEverything(SBWhitelistId::CSD);
   txn->WhitelistEverything(SBWhitelistId::DOWNLOAD);
   return true;
 }
 
 bool SafeBrowsingDatabaseNew::ContainsBrowseUrl(
     const GURL& url,
     std::vector<SBPrefix>* prefix_hits,
     std::vector<SBFullHashResult>* cache_hits) {
+  TRACE_EVENT0("toplevel", "SafeBrowsingDatabaseNew::ContainsBrowseUrl");
   return PrefixSetContainsUrl(url, PrefixSetId::BROWSE, prefix_hits,
                               cache_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsBrowseHashes(
     const std::vector<SBFullHash>& full_hashes,
     std::vector<SBPrefix>* prefix_hits,
     std::vector<SBFullHashResult>* cache_hits) {
   return PrefixSetContainsUrlHashes(full_hashes, PrefixSetId::BROWSE,
                                     prefix_hits, cache_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsUnwantedSoftwareUrl(
     const GURL& url,
     std::vector<SBPrefix>* prefix_hits,
     std::vector<SBFullHashResult>* cache_hits) {
+  TRACE_EVENT0("toplevel",
+               "SafeBrowsingDatabaseNew::ContainsUnwantedSoftwareUrl");
+
   return PrefixSetContainsUrl(url, PrefixSetId::UNWANTED_SOFTWARE, prefix_hits,
                               cache_hits);
 }
 
 bool SafeBrowsingDatabaseNew::ContainsUnwantedSoftwareHashes(
     const std::vector<SBFullHash>& full_hashes,
     std::vector<SBPrefix>* prefix_hits,
     std::vector<SBFullHashResult>* cache_hits) {
   return PrefixSetContainsUrlHashes(full_hashes, PrefixSetId::UNWANTED_SOFTWARE,
                                     prefix_hits, cache_hits);
 }
 
 bool SafeBrowsingDatabaseNew::PrefixSetContainsUrl(
     const GURL& url,
     PrefixSetId prefix_set_id,
     std::vector<SBPrefix>* prefix_hits,
     std::vector<SBFullHashResult>* cache_hits) {
+  TRACE_EVENT0("toplevel", "SafeBrowsingDatabaseNew::PrefixSetContainsUrl");
   std::vector<SBFullHash> full_hashes;
   UrlToFullHashes(url, false, &full_hashes);
   return PrefixSetContainsUrlHashes(full_hashes, prefix_set_id, prefix_hits,
                                     cache_hits);
 }
 
 bool SafeBrowsingDatabaseNew::PrefixSetContainsUrlHashes(
     const std::vector<SBFullHash>& full_hashes,
     PrefixSetId prefix_set_id,
     std::vector<SBPrefix>* prefix_hits,
     std::vector<SBFullHashResult>* cache_hits) {
   // Clear the results first.
   prefix_hits->clear();
   cache_hits->clear();
 
   if (full_hashes.empty())
     return false;
 
   // Used to determine cache expiration.
   const base::Time now = base::Time::Now();
 
   {
+    TRACE_EVENT0("toplevel",
+                 "SafeBrowsingDatabaseNew::PrefixSetContainsUrlHashes");
     scoped_ptr<ReadTransaction> txn = state_manager_.BeginReadTransaction();
 
     // |prefix_set| is empty until it is either read from disk, or the first
     // update populates it.  Bail out without a hit if not yet available.
     const PrefixSet* prefix_set = txn->GetPrefixSet(prefix_set_id);
     if (!prefix_set)
       return false;
 
-    for (size_t i = 0; i < full_hashes.size(); ++i) {
-      if (!GetCachedFullHash(txn->prefix_gethash_cache(), full_hashes[i], now,
-                             cache_hits)) {
-        // No valid cached result, check the database.
-        if (prefix_set->Exists(full_hashes[i]))
-          prefix_hits->push_back(full_hashes[i].prefix);
+    {
+      TRACE_EVENT0(
+          "toplevel",
+          "SafeBrowsingDatabaseNew::PrefixSetContainsUrlHashes::ForLoop");
+      for (size_t i = 0; i < full_hashes.size(); ++i) {
+        if (!GetCachedFullHash(txn->prefix_gethash_cache(), full_hashes[i], now,
+                               cache_hits)) {
+          // No valid cached result, check the database.
+          if (prefix_set->Exists(full_hashes[i]))
+            prefix_hits->push_back(full_hashes[i].prefix);
+        }
       }
     }
   }
 
-  // Multiple full hashes could share prefix, remove duplicates.
-  std::sort(prefix_hits->begin(), prefix_hits->end());
-  prefix_hits->erase(std::unique(prefix_hits->begin(), prefix_hits->end()),
-                     prefix_hits->end());
+  {
+    TRACE_EVENT0(
+        "toplevel",
+        "SafeBrowsingDatabaseNew::PrefixSetContainsUrlHashes::SortAndErase");
+    // Multiple full hashes could share prefix, remove duplicates.
+    std::sort(prefix_hits->begin(), prefix_hits->end());
+    prefix_hits->erase(std::unique(prefix_hits->begin(), prefix_hits->end()),
+                       prefix_hits->end());
+  }
 
   return !prefix_hits->empty() || !cache_hits->empty();
 }
 
 bool SafeBrowsingDatabaseNew::ContainsDownloadUrlPrefixes(
     const std::vector<SBPrefix>& prefixes,
     std::vector<SBPrefix>* prefix_hits) {
   DCHECK(db_task_runner_->RunsTasksOnCurrentThread());
 
   // Ignore this check when download checking is not enabled.
@@ skipping 976 matching lines @@
 
   // 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);
 }
 
 }  // namespace safe_browsing