[NOT FOR LANDING] Detailed loading traces

chrome/browser/safe_browsing/local_database_manager.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/local_database_manager.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/leak_tracker.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/trace_event/trace_event.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/client_side_detection_service.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/browser/safe_browsing/protocol_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_database.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
@@ skipping 277 matching lines @@
   // TODO(kalman): there really shouldn't be a flag for this.
   enable_extension_blacklist_ =
       !cmdline->HasSwitch(switches::kSbDisableExtensionBlacklist);
 
   // The client-side IP blacklist feature is tightly integrated with client-side
   // phishing protection for now.
   enable_ip_blacklist_ = enable_csd_whitelist_;
 }
 
 LocalSafeBrowsingDatabaseManager::~LocalSafeBrowsingDatabaseManager() {
+  TRACE_EVENT0(
+      "toplevel",
+      "LocalSafeBrowsingDatabaseManager::~LocalSafeBrowsingDatabaseManager");
+
   // The DCHECK is disabled due to crbug.com/438754.
   // DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // We should have already been shut down. If we're still enabled, then the
   // database isn't going to be closed properly, which could lead to corruption.
   DCHECK(!enabled_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::IsSupported() const {
   return true;
@@ skipping 170 matching lines @@
 bool LocalSafeBrowsingDatabaseManager::IsCsdWhitelistKillSwitchOn() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_ || !MakeDatabaseAvailable()) {
     return true;
   }
   return database_->IsCsdWhitelistKillSwitchOn();
 }
 
 bool LocalSafeBrowsingDatabaseManager::CheckBrowseUrl(const GURL& url,
                                                  Client* client) {
+  TRACE_EVENT0("toplevel", "LocalSafeBrowsingDatabaseManager::CheckBrowseUrl");
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!enabled_)
     return true;
 
   if (!CanCheckUrl(url))
     return true;
 
   std::vector<SBThreatType> expected_threats;
   expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
   expected_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
@@ skipping 26 matching lines @@
   std::vector<SBPrefix> unwanted_prefix_hits;
   std::vector<SBFullHashResult> unused_cache_hits;
   bool unwanted_prefix_match = database_->ContainsUnwantedSoftwareHashes(
       full_hashes, &unwanted_prefix_hits, &unused_cache_hits);
 
   // Merge the two pre-sorted prefix hits lists.
   // TODO(gab): Refactor SafeBrowsingDatabase for it to return this merged list
   // by default rather than building it here.
   std::vector<SBPrefix> prefix_hits(browse_prefix_hits.size() +
                                     unwanted_prefix_hits.size());
-  std::merge(browse_prefix_hits.begin(),
-             browse_prefix_hits.end(),
-             unwanted_prefix_hits.begin(),
-             unwanted_prefix_hits.end(),
-             prefix_hits.begin());
-  prefix_hits.erase(std::unique(prefix_hits.begin(), prefix_hits.end()),
-                    prefix_hits.end());
+  {
+    TRACE_EVENT0(
+        "toplevel",
+        "LocalSafeBrowsingDatabaseManager::CheckBrowseUrl::MergeAndErase");
+
+    std::merge(browse_prefix_hits.begin(), browse_prefix_hits.end(),
+               unwanted_prefix_hits.begin(), unwanted_prefix_hits.end(),
+               prefix_hits.begin());
+    prefix_hits.erase(std::unique(prefix_hits.begin(), prefix_hits.end()),
+                      prefix_hits.end());
+  }
 
   UMA_HISTOGRAM_TIMES("SB2.FilterCheck", base::TimeTicks::Now() - start);
 
   if (!browse_prefix_match && !unwanted_prefix_match)
     return true;  // URL is okay.
 
   // Needs to be asynchronous, since we could be in the constructor of a
   // ResourceDispatcherHost event handler which can't pause there.
   // This check will ping the Safe Browsing servers and get all lists which it
   // matches. These lists will then be filtered against the |expected_threats|
@@ skipping 708 matching lines @@
       FROM_HERE, base::Bind(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
                             check->weak_ptr_factory_->GetWeakPtr(), check),
       check_timeout_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::download_protection_enabled() const {
   return enable_download_protection_;
 }
 
 }  // namespace safe_browsing