- Added support for keeping track of load times....

webkit/glue/webframeloaderclient_impl.cc

 // Copyright (c) 2006-2008 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 "config.h"
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 
@@ skipping 11 matching lines @@
 #include "FormState.h"
 #include "FrameLoader.h"
 #include "FrameLoadRequest.h"
 #include "FrameView.h"
 #include "MIMETypeRegistry.h"
 #include "MouseEvent.h"
 #include "Page.h"
 #include "PlatformString.h"
 #include "PluginData.h"
 #include "RefPtr.h"
+#include "StringExtras.h"
 #include "WindowFeatures.h"
 MSVC_POP_WARNING();
 
 #undef LOG
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
@@ skipping 11 matching lines @@
 #include "webkit/glue/webdevtoolsagent_impl.h"
 #include "webkit/glue/weberror_impl.h"
 #include "webkit/glue/webframeloaderclient_impl.h"
 #include "webkit/glue/webhistoryitem_impl.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webplugin_impl.h"
 #include "webkit/glue/webresponse_impl.h"
 #include "webkit/glue/webview_delegate.h"
 #include "webkit/glue/webview_impl.h"
 #include "webkit/glue/weburlrequest.h"
+#include "webkit/glue/weburlrequest_impl.h"
 
 using namespace WebCore;
+using base::Time;
+using base::TimeDelta;
 
 // Domain for internal error codes.
 static const char kInternalErrorDomain[] = "webkit_glue";
 
 // An internal error code.  Used to note a policy change error resulting from
 // dispatchDecidePolicyForMIMEType not passing the PolicyUse option.
 enum {
   ERR_POLICY_CHANGE = -10000,
 };
 
@@ skipping 301 matching lines @@
   }
   NetAgentImpl* net_agent = GetNetAgentImpl();
   if (net_agent) {
     net_agent->DidFailLoading(loader, identifier, error);
   }
 }
 
 void WebFrameLoaderClient::dispatchDidFinishDocumentLoad() {
   WebViewImpl* webview = webframe_->webview_impl();
   WebViewDelegate* d = webview->delegate();
+  DocumentLoader* documentLoader =
+      webframe_->frame()->loader()->activeDocumentLoader();
+  WebDataSourceImpl* data_source =
+      WebDataSourceImpl::FromLoader(documentLoader);
 
   // A frame may be reused.  This call ensures we don't hold on to our password
   // listeners and their associated HTMLInputElements.
   webframe_->ClearPasswordListeners();
 
   // The document has now been fully loaded.
   // Scan for password forms to be sent to the browser
   PassRefPtr<WebCore::HTMLCollection> forms =
       webframe_->frame()->document()->forms();
 
@@ skipping 16 matching lines @@
 
       if (passwordFormPtr.get())
         passwordForms.push_back(*passwordFormPtr);
     }
   }
 
   if (d && (passwordForms.size() > 0))
     d->OnPasswordFormsSeen(webview, passwordForms);
   if (d)
     d->DidFinishDocumentLoadForFrame(webview, webframe_);
+  data_source->set_finish_document_load_time(base::Time::Now());
 }
 
 bool WebFrameLoaderClient::dispatchDidLoadResourceFromMemoryCache(
     DocumentLoader* loader,
     const ResourceRequest& request,
     const ResourceResponse& response,
     int length) {
   WebViewImpl* webview = webframe_->webview_impl();
   WebViewDelegate* d = webview->delegate();
 
@@ skipping 292 matching lines @@
   ds->AppendRedirect(url);
 
   if (d) {
     // As the comment for DidCompleteClientRedirect in webview_delegate.h
     // points out, whatever information its invocation contains should only
     // be considered relevant until the next provisional load has started.
     // So we first tell the delegate that the load started, and then tell it
     // about the client redirect the load is responsible for completing.
     d->DidStartProvisionalLoadForFrame(webview, webframe_,
                                        NavigationGestureForLastLoad());
+    DocumentLoader* documentLoader =
+        webframe_->frame()->loader()->activeDocumentLoader();
+    WebDataSourceImpl* dataSource =
+        WebDataSourceImpl::FromLoader(documentLoader);
+    if (dataSource->GetRequestTime().ToInternalValue() == 0) {
+      const Event *event = documentLoader->triggeringAction().event();
+      if (event) {
+        // If the request was generated by a click, we have to use the time
+        // from the event. Unfortunately this isn't tracked all the way from
+        // the platform event, but it will have to do
+        double eventTime = event->timeStamp() / 1000.0;
+        dataSource->set_request_time(Time::FromDoubleT(eventTime));
+      }
+    }
+    dataSource->set_start_load_time(base::Time::Now());
     if (completing_client_redirect)
       d->DidCompleteClientRedirect(webview, webframe_,
                                    expected_client_redirect_src_);
   }
 
   // Cancel any pending loads.
   if (alt_404_page_fetcher_.get())
     alt_404_page_fetcher_->Cancel();
 }
 
@@ skipping 52 matching lines @@
   WebPluginDelegate* plg_delegate = webframe_->plugin_delegate();
   if (plg_delegate)
     plg_delegate->DidFinishLoadWithReason(NPRES_NETWORK_ERR);
 
   // Don't clear the redirect chain, this will happen in the middle of client
   // redirects, and we need the context. The chain will be cleared when the
   // provisional load succeeds or fails, not the "real" one.
 }
 
 void WebFrameLoaderClient::dispatchDidFinishLoad() {
+  DocumentLoader* documentLoader =
+      webframe_->frame()->loader()->activeDocumentLoader();
+  WebDataSourceImpl* dataSource =
+      WebDataSourceImpl::FromLoader(documentLoader);
   WebViewImpl* webview = webframe_->webview_impl();
   WebViewDelegate* d = webview->delegate();
+  dataSource->set_finish_load_time(base::Time::Now());
   if (d)
     d->DidFinishLoadForFrame(webview, webframe_);
   WebPluginDelegate* plg_delegate = webframe_->plugin_delegate();
   if (plg_delegate)
     plg_delegate->DidFinishLoadWithReason(NPRES_DONE);
 
   // Don't clear the redirect chain, this will happen in the middle of client
   // redirects, and we need the context. The chain will be cleared when the
   // provisional load succeeds or fails, not the "real" one.
 }
@@ skipping 114 matching lines @@
 
     // Remember the disposition for when dispatchCreatePage is called.  It is
     // unfortunate that WebCore does not provide us with any context when
     // creating or showing the new window that would allow us to avoid having
     // to keep this state.
     next_window_open_disposition_ = disposition;
   }
   (webframe_->frame()->loader()->*function)(policy_action);
 }
 
-// Conversion.
-static WebNavigationType NavigationTypeToWebNavigationType(
-    WebCore::NavigationType t) {
-  switch (t) {
-    case WebCore::NavigationTypeLinkClicked:
-      return WebNavigationTypeLinkClicked;
-    case WebCore::NavigationTypeFormSubmitted:
-      return WebNavigationTypeFormSubmitted;
-    case WebCore::NavigationTypeBackForward:
-      return WebNavigationTypeBackForward;
-    case WebCore::NavigationTypeReload:
-      return WebNavigationTypeReload;
-    case WebCore::NavigationTypeFormResubmitted:
-      return WebNavigationTypeFormResubmitted;
-    default:
-    case WebCore::NavigationTypeOther:
-      return WebNavigationTypeOther;
-  }
-}
-
 void WebFrameLoaderClient::dispatchDecidePolicyForNavigationAction(
     WebCore::FramePolicyFunction function,
     const WebCore::NavigationAction& action,
     const WebCore::ResourceRequest& request,
     PassRefPtr<WebCore::FormState> form_state) {
   PolicyAction policy_action = PolicyUse;
 
   WebViewImpl* wv = webframe_->webview_impl();
   WebViewDelegate* d = wv->delegate();
   // It is valid for this function to be invoked in code paths where the
   // the webview is closed.
   // The NULL check here is to fix a crash that seems strange
   // (see - https://bugs.webkit.org/show_bug.cgi?id=23554).
   if (d && !request.url().isNull()) {
     WindowOpenDisposition disposition = CURRENT_TAB;
     ActionSpecifiesDisposition(action, &disposition);
 
     // Give the delegate a chance to change the disposition.  When we do not
     // have a provisional data source here, it means that we are scrolling to
     // an anchor in the page.  We don't need to ask the WebViewDelegate about
     // such navigations.
     const WebDataSourceImpl* ds = webframe_->GetProvisionalDataSourceImpl();
     if (ds) {
       bool is_redirect = !ds->GetRedirectChain().empty();
 
       WebNavigationType webnav_type =
-          NavigationTypeToWebNavigationType(action.type());
+          WebDataSourceImpl::NavigationTypeToWebNavigationType(action.type());
 
       disposition = d->DispositionForNavigationAction(
           wv, webframe_, &ds->GetRequest(), webnav_type, disposition, is_redirect);
 
       if (disposition != IGNORE_ACTION) {
         if (disposition == CURRENT_TAB) {
           policy_action = PolicyUse;
         } else if (disposition == SAVE_TO_DISK) {
           policy_action = PolicyDownload;
         } else {
@@ skipping 587 matching lines @@
   if (!web_view) {
     return NULL;
   }
   WebDevToolsAgentImpl* tools_agent = web_view->GetWebDevToolsAgentImpl();
   if (tools_agent) {
     return tools_agent->net_agent_impl();
   } else {
     return NULL;
   }
 }