LoadTiming in net part 7: Hooking it all up

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_resource_throttle.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/user_script_listener.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
-#include "chrome/browser/net/load_timing_observer.h"
 #include "chrome/browser/net/resource_prefetch_predictor_observer.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/renderer_host/chrome_url_request_user_data.h"
 #include "chrome/browser/renderer_host/safe_browsing_resource_throttle_factory.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/ui/auto_login_prompter.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/resource_request_info.h"
+#include "content/public/common/resource_response.h"
 #include "net/base/load_flags.h"
+#include "net/base/load_timing_info.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/managed_mode/managed_mode_resource_throttle.h"
 #endif
 
 #if defined(USE_SYSTEM_PROTOBUF)
 #include <google/protobuf/repeated_field.h>
@@ skipping 23 matching lines @@
                                                render_view_id);
   if (!rvh)
     return;
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_DOWNLOAD_INITIATED,
       content::Source<RenderViewHost>(rvh),
       content::NotificationService::NoDetails());
 }
 
+// The network stack returns actual connect times, while the renderer process
+// expects times that the request was blocked in each phase of setting up
+// a connection.  Due to preconnect and late binding, it is possible for a
+// connection attempt to start before a request has been started, so this
+// function is needed to convert times from the network stack to times the
+// renderer process expects.
+void FixupLoadTimingInfo(net::LoadTimingInfo* load_timing_info) {
+  // If there are no times, do nothing.
+  if (load_timing_info->request_start.is_null())
+    return;
+
+  // Starting the request and resolving the proxy are the only phases of the
+  // request that occur before it blocks on starting a connection.
+  base::TimeTicks block_on_connect_start = load_timing_info->request_start;
+  if (!load_timing_info->proxy_resolve_end.is_null())
+    block_on_connect_start = load_timing_info->proxy_resolve_end;
+
+  net::LoadTimingInfo::ConnectTiming* connect_timing =
+      &load_timing_info->connect_timing;
+  if (!connect_timing->dns_start.is_null()) {
+    DCHECK(!connect_timing->dns_end.is_null());
+    if (connect_timing->dns_start < block_on_connect_start)
+      connect_timing->dns_start = block_on_connect_start;
+    if (connect_timing->dns_end < block_on_connect_start)
+      connect_timing->dns_end = block_on_connect_start;
+  }
+
+  if (!connect_timing->connect_start.is_null()) {
+    DCHECK(!connect_timing->connect_end.is_null());
+    if (connect_timing->connect_start < block_on_connect_start)
+      connect_timing->connect_start = block_on_connect_start;
+    if (connect_timing->connect_end < block_on_connect_start)
+      connect_timing->connect_end = block_on_connect_start;
+  }
+
+  if (!connect_timing->ssl_start.is_null()) {
+    DCHECK(!connect_timing->ssl_end.is_null());
+    if (connect_timing->ssl_start < block_on_connect_start)
+      connect_timing->ssl_start = block_on_connect_start;
+    if (connect_timing->ssl_end < block_on_connect_start)
+      connect_timing->ssl_end = block_on_connect_start;
+  }
+}
+
 }  // end namespace
 
 ChromeResourceDispatcherHostDelegate::ChromeResourceDispatcherHostDelegate(
     prerender::PrerenderTracker* prerender_tracker)
     : download_request_limiter_(g_browser_process->download_request_limiter()),
       safe_browsing_(g_browser_process->safe_browsing_service()),
       user_script_listener_(new extensions::UserScriptListener()),
       prerender_tracker_(prerender_tracker) {
 }
 
@@ skipping 270 matching lines @@
     const GURL& url, const std::string& mime_type) {
   // Special-case user scripts to get downloaded instead of viewed.
   return extensions::UserScript::IsURLUserScript(url, mime_type);
 }
 
 void ChromeResourceDispatcherHostDelegate::OnResponseStarted(
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::ResourceResponse* response,
     IPC::Sender* sender) {
-  LoadTimingObserver::PopulateTimingInfo(request, response);
+  // TODO(mmenke):  Figure out if LOAD_ENABLE_LOAD_TIMING is safe to remove.
+  if (request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING) {
+    request->GetLoadTimingInfo(&response->head.load_timing);
+    FixupLoadTimingInfo(&response->head.load_timing);
+  }
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 
   if (request->url().SchemeIsSecure()) {
     const net::URLRequestContext* context = request->context();
     net::TransportSecurityState* state = context->transport_security_state();
     if (state) {
       net::TransportSecurityState::DomainState domain_state;
       bool has_sni = net::SSLConfigService::IsSNIAvailable(
           context->ssl_config_service());
@@ skipping 38 matching lines @@
     io_data->resource_prefetch_predictor_observer()->OnResponseStarted(request);
 
   prerender::URLRequestResponseStarted(request);
 }
 
 void ChromeResourceDispatcherHostDelegate::OnRequestRedirected(
     const GURL& redirect_url,
     net::URLRequest* request,
     content::ResourceContext* resource_context,
     content::ResourceResponse* response) {
-  LoadTimingObserver::PopulateTimingInfo(request, response);
+  // TODO(mmenke):  Figure out if LOAD_ENABLE_LOAD_TIMING is safe to remove.
+  if (request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING) {
+    request->GetLoadTimingInfo(&response->head.load_timing);
+    FixupLoadTimingInfo(&response->head.load_timing);
+  }
 
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context);
 
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 
   AppendChromeSyncGaiaHeader(request, resource_context);
 
   // See if the response contains the Google-Accounts-SignIn header.  If so,
   // then the user has just finished signing in, and the server is allowing the
   // browser to suggest connecting the user's profile to the account.
   OneClickSigninHelper::ShowInfoBarIfPossible(request, io_data,
                                               info->GetChildID(),
                                               info->GetRouteID());
 #endif
 
   if (io_data->resource_prefetch_predictor_observer()) {
     io_data->resource_prefetch_predictor_observer()->OnRequestRedirected(
         redirect_url, request);
   }
 }