Tracing for NavigationHandle lifetime and state.

content/browser/frame_host/navigation_handle_impl.cc

 // Copyright 2015 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 "content/browser/frame_host/navigation_handle_impl.h"
 
 #include <iterator>
 
 #include "base/logging.h"
 #include "content/browser/appcache/appcache_navigation_handle.h"
@@ skipping 102 matching lines @@
       redirect_chain_(redirect_chain),
       is_download_(false),
       is_stream_(false),
       started_from_context_menu_(started_from_context_menu),
       reload_type_(ReloadType::NONE),
       restore_type_(RestoreType::NONE),
       navigation_type_(NAVIGATION_TYPE_UNKNOWN),
       should_check_main_world_csp_(should_check_main_world_csp),
       is_form_submission_(is_form_submission),
       weak_factory_(this) {
+  TRACE_EVENT_ASYNC_BEGIN2("navigation", "NavigationHandle", this,
+                           "frame_tree_node",
+                           frame_tree_node_->frame_tree_node_id(), "url",
+                           url_.possibly_invalid_spec());
   DCHECK(!navigation_start.is_null());
   if (redirect_chain_.empty())
     redirect_chain_.push_back(url);
 
   starting_site_instance_ =
       frame_tree_node_->current_frame_host()->GetSiteInstance();
 
   if (pending_nav_entry_id_) {
     NavigationControllerImpl* nav_controller =
         static_cast<NavigationControllerImpl*>(
@@ skipping 14 matching lines @@
   }
 
   if (!IsRendererDebugURL(url_))
     GetDelegate()->DidStartNavigation(this);
 
   if (IsInMainFrame()) {
     TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP1(
         "navigation", "Navigation StartToCommit", this,
         navigation_start, "Initial URL", url_.spec());
   }
+
+  if (is_same_page_) {
+    TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                                 "Same document");
+  }
 }
 
 NavigationHandleImpl::~NavigationHandleImpl() {
   // Transfer requests that have not matched up with another navigation request
   // from the renderer need to be cleaned up. These are marked as protected in
   // the RDHI, so they do not get cancelled when frames are destroyed.
   if (is_transferring()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&NotifyAbandonedTransferNavigation, GetGlobalRequestID()));
   }
 
   if (!IsRendererDebugURL(url_))
     GetDelegate()->DidFinishNavigation(this);
 
   // Cancel the navigation on the IO thread if the NavigationHandle is being
   // destroyed in the middle of the NavigationThrottles checks.
   if (!IsBrowserSideNavigationEnabled() && !complete_callback_.is_null())
     RunCompleteCallback(NavigationThrottle::CANCEL_AND_IGNORE);
 
   if (IsInMainFrame()) {
     TRACE_EVENT_ASYNC_END2("navigation", "Navigation StartToCommit", this,
                            "URL", url_.spec(), "Net Error Code",
                            net_error_code_);
   }
+  TRACE_EVENT_ASYNC_END0("navigation", "NavigationHandle", this);
 }
 
 NavigatorDelegate* NavigationHandleImpl::GetDelegate() const {
   return frame_tree_node_->navigator()->GetDelegate();
 }
 
 const GURL& NavigationHandleImpl::GetURL() {
   return url_;
 }
 
@@ skipping 128 matching lines @@
 net::HostPortPair NavigationHandleImpl::GetSocketAddress() {
   DCHECK(state_ == DID_COMMIT || state_ == DID_COMMIT_ERROR_PAGE);
   return socket_address_;
 }
 
 void NavigationHandleImpl::Resume() {
   if (state_ != DEFERRING_START && state_ != DEFERRING_REDIRECT &&
       state_ != DEFERRING_RESPONSE) {
     return;
   }
+  TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                               "Resume");
 
   NavigationThrottle::ThrottleCheckResult result = NavigationThrottle::DEFER;
   if (state_ == DEFERRING_START) {
     result = CheckWillStartRequest();
   } else if (state_ == DEFERRING_REDIRECT) {
     result = CheckWillRedirectRequest();
   } else {
     result = CheckWillProcessResponse();
 
     // If the navigation is about to proceed after having been deferred while
     // processing the response, then it's ready to commit. Determine which
     // RenderFrameHost should render the response, based on its site (after any
     // redirects).
     // Note: if MaybeTransferAndProceed returns false, this means that this
     // NavigationHandle was deleted, so return immediately.
     if (result == NavigationThrottle::PROCEED && !MaybeTransferAndProceed())
       return;
   }
 
-  if (result != NavigationThrottle::DEFER)
+  if (result != NavigationThrottle::DEFER) {
+    TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                                 "Resuming");
     RunCompleteCallback(result);
+  }
 }
 
 void NavigationHandleImpl::CancelDeferredNavigation(
     NavigationThrottle::ThrottleCheckResult result) {
   DCHECK(state_ == DEFERRING_START ||
          state_ == DEFERRING_REDIRECT ||
          state_ == DEFERRING_RESPONSE);
   DCHECK(result == NavigationThrottle::CANCEL_AND_IGNORE ||
          result == NavigationThrottle::CANCEL);
+  TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                               "CancelDeferredNavigation");
   state_ = CANCELING;
   RunCompleteCallback(result);
 }
 
 void NavigationHandleImpl::RegisterThrottleForTesting(
     std::unique_ptr<NavigationThrottle> navigation_throttle) {
   throttles_.push_back(std::move(navigation_throttle));
 }
 
 NavigationThrottle::ThrottleCheckResult
@@ skipping 134 matching lines @@
 void NavigationHandleImpl::WillStartRequest(
     const std::string& method,
     scoped_refptr<content::ResourceRequestBodyImpl> resource_request_body,
     const Referrer& sanitized_referrer,
     bool has_user_gesture,
     ui::PageTransition transition,
     bool is_external_protocol,
     RequestContextType request_context_type,
     blink::WebMixedContentContextType mixed_content_context_type,
     const ThrottleChecksFinishedCallback& callback) {
+  TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                               "WillStartRequest");
   if (method != "POST")
     DCHECK(!resource_request_body);
 
   // Update the navigation parameters.
   method_ = method;
   if (method_ == "POST")
     resource_request_body_ = resource_request_body;
   has_user_gesture_ = has_user_gesture;
   transition_ = transition;
   // Mirrors the logic in RenderFrameImpl::SendDidCommitProvisionalLoad.
@@ skipping 19 matching lines @@
 
   RegisterNavigationThrottles();
 
   if (IsBrowserSideNavigationEnabled())
     navigation_ui_data_ = GetDelegate()->GetNavigationUIData(this);
 
   // Notify each throttle of the request.
   NavigationThrottle::ThrottleCheckResult result = CheckWillStartRequest();
 
   // If the navigation is not deferred, run the callback.
-  if (result != NavigationThrottle::DEFER)
+  if (result != NavigationThrottle::DEFER) {
+    TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
+                                 "StartRequest", "result", result);
     RunCompleteCallback(result);
+  }
 }
 
 void NavigationHandleImpl::WillRedirectRequest(
     const GURL& new_url,
     const std::string& new_method,
     const GURL& new_referrer_url,
     bool new_is_external_protocol,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     net::HttpResponseInfo::ConnectionInfo connection_info,
     const ThrottleChecksFinishedCallback& callback) {
+  TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
+                               "WillRedirectRequest", "url",
+                               new_url.possibly_invalid_spec());
+
   // Update the navigation parameters.
   url_ = new_url;
   method_ = new_method;
 
   if (!(transition_ & ui::PAGE_TRANSITION_CLIENT_REDIRECT)) {
     sanitized_referrer_.url = new_referrer_url;
     sanitized_referrer_ =
         Referrer::SanitizeForRequest(url_, sanitized_referrer_);
   }
 
@@ skipping 11 matching lines @@
   if (IsSelfReferentialURL()) {
     state_ = CANCELING;
     RunCompleteCallback(NavigationThrottle::CANCEL);
     return;
   }
 
   // Notify each throttle of the request.
   NavigationThrottle::ThrottleCheckResult result = CheckWillRedirectRequest();
 
   // If the navigation is not deferred, run the callback.
-  if (result != NavigationThrottle::DEFER)
+  if (result != NavigationThrottle::DEFER) {
+    TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
+                                 "RedirectRequest", "result", result);
     RunCompleteCallback(result);
+  }
 }
 
 void NavigationHandleImpl::WillProcessResponse(
     RenderFrameHostImpl* render_frame_host,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     net::HttpResponseInfo::ConnectionInfo connection_info,
     const SSLStatus& ssl_status,
     const GlobalRequestID& request_id,
     bool should_replace_current_entry,
     bool is_download,
     bool is_stream,
     const base::Closure& transfer_callback,
     const ThrottleChecksFinishedCallback& callback) {
+  TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                               "WillProcessResponse");
+
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
   render_frame_host_ = render_frame_host;
   response_headers_ = response_headers;
   connection_info_ = connection_info;
   request_id_ = request_id;
   should_replace_current_entry_ = should_replace_current_entry;
   is_download_ = is_download;
   is_stream_ = is_stream;
   state_ = WILL_PROCESS_RESPONSE;
   ssl_status_ = ssl_status;
   complete_callback_ = callback;
   transfer_callback_ = transfer_callback;
 
   // Notify each throttle of the response.
   NavigationThrottle::ThrottleCheckResult result = CheckWillProcessResponse();
 
   // If the navigation is done processing the response, then it's ready to
   // commit. Determine which RenderFrameHost should render the response, based
   // on its site (after any redirects).
   // Note: if MaybeTransferAndProceed returns false, this means that this
   // NavigationHandle was deleted, so return immediately.
   if (result == NavigationThrottle::PROCEED && !MaybeTransferAndProceed())
     return;
 
   // If the navigation is not deferred, run the callback.
-  if (result != NavigationThrottle::DEFER)
+  if (result != NavigationThrottle::DEFER) {
+    TRACE_EVENT_ASYNC_STEP_INTO1("navigation", "NavigationHandle", this,
+                                 "ProcessResponse", "result", result);
     RunCompleteCallback(result);
+  }
 }
 
 void NavigationHandleImpl::ReadyToCommitNavigation(
     RenderFrameHostImpl* render_frame_host) {
+  TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                               "ReadyToCommitNavigation");
+
   DCHECK(!render_frame_host_ || render_frame_host_ == render_frame_host);
   render_frame_host_ = render_frame_host;
   state_ = READY_TO_COMMIT;
 
   if (!IsRendererDebugURL(url_) && !IsSameDocument())
     GetDelegate()->ReadyToCommitNavigation(this);
 }
 
 void NavigationHandleImpl::DidCommitNavigation(
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
@@ skipping 19 matching lines @@
 
   DCHECK(!IsInMainFrame() || navigation_entry_committed)
       << "Only subframe navigations can get here without changing the "
       << "NavigationEntry";
   subframe_entry_committed_ = navigation_entry_committed;
 
   // If an error page reloads, net_error_code might be 200 but we still want to
   // count it as an error page.
   if (params.base_url.spec() == kUnreachableWebDataURL ||
       net_error_code_ != net::OK) {
+    TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                                 "DidCommitNavigation: error page");
     state_ = DID_COMMIT_ERROR_PAGE;
   } else {
+    TRACE_EVENT_ASYNC_STEP_INTO0("navigation", "NavigationHandle", this,
+                                 "DidCommitNavigation");
     state_ = DID_COMMIT;
   }
 }
 
 void NavigationHandleImpl::Transfer() {
   DCHECK(!IsBrowserSideNavigationEnabled());
   // This is an actual transfer. Inform the NavigationResourceThrottle. This
   // will allow to mark the URLRequest as transferring. When it is marked as
   // transferring, the URLRequest can no longer be cancelled by its original
   // RenderFrame. Instead it will persist until being picked up by the transfer
   // RenderFrame, even if the original RenderFrame is destroyed.
   // Note: |transfer_callback_| can be null in unit tests.
   if (!transfer_callback_.is_null())
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, transfer_callback_);
   transfer_callback_.Reset();
 }
 
 NavigationThrottle::ThrottleCheckResult
 NavigationHandleImpl::CheckWillStartRequest() {
   DCHECK(state_ == WILL_SEND_REQUEST || state_ == DEFERRING_START);
   DCHECK(state_ != WILL_SEND_REQUEST || next_index_ == 0);
   DCHECK(state_ != DEFERRING_START || next_index_ != 0);
   for (size_t i = next_index_; i < throttles_.size(); ++i) {
     NavigationThrottle::ThrottleCheckResult result =
         throttles_[i]->WillStartRequest();
+    TRACE_EVENT_ASYNC_STEP_INTO0(
+        "navigation", "NavigationHandle", this,
+        base::StringPrintf("CheckWillStartRequest: %s: %d",
+                           throttles_[i]->GetNameForLogging(), result));
     switch (result) {
       case NavigationThrottle::PROCEED:
         continue;
 
       case NavigationThrottle::BLOCK_REQUEST:
       case NavigationThrottle::CANCEL:
       case NavigationThrottle::CANCEL_AND_IGNORE:
         state_ = CANCELING;
         return result;
 
       case NavigationThrottle::DEFER:
         state_ = DEFERRING_START;
         next_index_ = i + 1;
         return result;
 
       case NavigationThrottle::BLOCK_RESPONSE:
         NOTREACHED();
     }
   }
   next_index_ = 0;
   state_ = WILL_SEND_REQUEST;
+
   return NavigationThrottle::PROCEED;
 }
 
 NavigationThrottle::ThrottleCheckResult
 NavigationHandleImpl::CheckWillRedirectRequest() {
   DCHECK(state_ == WILL_REDIRECT_REQUEST || state_ == DEFERRING_REDIRECT);
   DCHECK(state_ != WILL_REDIRECT_REQUEST || next_index_ == 0);
   DCHECK(state_ != DEFERRING_REDIRECT || next_index_ != 0);
+
   for (size_t i = next_index_; i < throttles_.size(); ++i) {
     NavigationThrottle::ThrottleCheckResult result =
         throttles_[i]->WillRedirectRequest();
+    TRACE_EVENT_ASYNC_STEP_INTO0(
+        "navigation", "NavigationHandle", this,
+        base::StringPrintf("CheckWillRedirectRequest: %s: %d",
+                           throttles_[i]->GetNameForLogging(), result));
     switch (result) {
       case NavigationThrottle::PROCEED:
         continue;
 
       case NavigationThrottle::BLOCK_REQUEST:
         CHECK(IsBrowserSideNavigationEnabled())
             << "BLOCK_REQUEST must not be used on redirect without PlzNavigate";
       case NavigationThrottle::CANCEL:
       case NavigationThrottle::CANCEL_AND_IGNORE:
         state_ = CANCELING;
@@ skipping 16 matching lines @@
     GetDelegate()->DidRedirectNavigation(this);
 
   return NavigationThrottle::PROCEED;
 }
 
 NavigationThrottle::ThrottleCheckResult
 NavigationHandleImpl::CheckWillProcessResponse() {
   DCHECK(state_ == WILL_PROCESS_RESPONSE || state_ == DEFERRING_RESPONSE);
   DCHECK(state_ != WILL_PROCESS_RESPONSE || next_index_ == 0);
   DCHECK(state_ != DEFERRING_RESPONSE || next_index_ != 0);
+
   for (size_t i = next_index_; i < throttles_.size(); ++i) {
     NavigationThrottle::ThrottleCheckResult result =
         throttles_[i]->WillProcessResponse();
+    TRACE_EVENT_ASYNC_STEP_INTO0(
+        "navigation", "NavigationHandle", this,
+        base::StringPrintf("CheckWillProcessResponse: %s: %d",
+                           throttles_[i]->GetNameForLogging(), result));
     switch (result) {
       case NavigationThrottle::PROCEED:
         continue;
 
       case NavigationThrottle::CANCEL:
       case NavigationThrottle::CANCEL_AND_IGNORE:
       case NavigationThrottle::BLOCK_RESPONSE:
         state_ = CANCELING;
         return result;
 
       case NavigationThrottle::DEFER:
         state_ = DEFERRING_RESPONSE;
         next_index_ = i + 1;
         return result;
 
       case NavigationThrottle::BLOCK_REQUEST:
         NOTREACHED();
     }
   }
   next_index_ = 0;
   state_ = WILL_PROCESS_RESPONSE;
+
   return NavigationThrottle::PROCEED;
 }
 
 bool NavigationHandleImpl::MaybeTransferAndProceed() {
   DCHECK_EQ(WILL_PROCESS_RESPONSE, state_);
 
   // Check if the navigation should transfer. This may result in the
   // destruction of this NavigationHandle, and the cancellation of the request.
   if (!MaybeTransferAndProceedInternal())
     return false;
@@ skipping 179 matching lines @@
     if (node->current_url().EqualsIgnoringRef(url_)) {
       if (found_self_reference)
         return true;
       found_self_reference = true;
     }
   }
   return false;
 }
 
 }  // namespace content