[NOT FOR LANDING] Detailed loading traces

chrome/browser/renderer_host/safe_browsing_resource_throttle.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/renderer_host/safe_browsing_resource_throttle.h"
 
 #include <utility>
 
+#include "base/trace_event/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "components/safe_browsing_db/util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 72 matching lines @@
       defer_state_(DEFERRED_NONE),
       threat_type_(safe_browsing::SB_THREAT_TYPE_SAFE),
       database_manager_(sb_service->database_manager()),
       ui_manager_(sb_service->ui_manager()),
       request_(request),
       resource_type_(resource_type),
       bound_net_log_(net::BoundNetLog::Make(request->net_log().net_log(),
                                             NetLog::SOURCE_SAFE_BROWSING)) {}
 
 SafeBrowsingResourceThrottle::~SafeBrowsingResourceThrottle() {
+  TRACE_EVENT0("toplevel",
+               "SafeBrowsingResourceThrottle::~SafeBrowsingResourceThrottle");
+
   if (defer_state_ != DEFERRED_NONE) {
     EndNetLogEvent(NetLog::TYPE_SAFE_BROWSING_DEFERRED, nullptr, nullptr);
   }
 
   if (state_ == STATE_CHECKING_URL) {
     database_manager_->CancelCheck(this);
     EndNetLogEvent(NetLog::TYPE_SAFE_BROWSING_CHECKING_URL, "result",
                    "request_canceled");
   }
 }
@@ skipping 14 matching lines @@
 void SafeBrowsingResourceThrottle::EndNetLogEvent(NetLog::EventType type,
                                                   const char* name,
                                                   const char* value) {
   bound_net_log_.EndEvent(
       type, base::Bind(&NetLogStringCallback, name, value));
   request_->net_log().AddEvent(
       type, bound_net_log_.source().ToEventParametersCallback());
 }
 
 void SafeBrowsingResourceThrottle::WillStartRequest(bool* defer) {
+  TRACE_EVENT0("toplevel", "SafeBrowsingResourceThrottle::WillStartRequest");
+
   // We need to check the new URL before starting the request.
   if (CheckUrl(request_->url()))
     return;
 
   // We let the check run in parallel with resource load only if this
   // db_manager only supports asynchronous checks, like on mobile.
   // Otherwise, we defer now.
   if (database_manager_->ChecksAreAlwaysAsync())
     return;
 
@@ skipping 171 matching lines @@
     threat_type_ = safe_browsing::SB_THREAT_TYPE_SAFE;
     if (defer_state_ != DEFERRED_NONE) {
       ResumeRequest();
     }
   } else {
     controller()->Cancel();
   }
 }
 
 bool SafeBrowsingResourceThrottle::CheckUrl(const GURL& url) {
+  TRACE_EVENT0("toplevel", "SafeBrowsingResourceThrottle::CheckUrl");
   TRACE_EVENT1("loader", "SafeBrowsingResourceThrottle::CheckUrl", "url",
                url.spec());
   CHECK_EQ(state_, STATE_NONE);
   // To reduce aggregate latency on mobile, check only the most dangerous
   // resource types.
   if (!database_manager_->CanCheckResourceType(resource_type_)) {
     UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes2.Skipped", resource_type_,
                               content::RESOURCE_TYPE_LAST_TYPE);
     return true;
   }
 
-  bool succeeded_synchronously = database_manager_->CheckBrowseUrl(url, this);
+  bool succeeded_synchronously;
+  {
+    TRACE_EVENT0("toplevel", "SafeBrowsingDatabaseManaager::CheckBrowseUrl");
+    succeeded_synchronously = database_manager_->CheckBrowseUrl(url, this);
+  }
+
   UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes2.Checked", resource_type_,
                             content::RESOURCE_TYPE_LAST_TYPE);
 
   if (succeeded_synchronously) {
     RecordHistogramResourceTypeSafe(resource_type_);
     threat_type_ = safe_browsing::SB_THREAT_TYPE_SAFE;
     ui_manager_->LogPauseDelay(base::TimeDelta());  // No delay.
     return true;
   }
 
@@ skipping 36 matching lines @@
                        unchecked_redirect_url_, "defer_reason",
                        "resumed_redirect");
     }
   }
 
   if (resume) {
     defer_state_ = DEFERRED_NONE;
     controller()->Resume();
   }
 }