From 8a3125a7100ffc53f6731604fcf299ab9331e0ba Mon Sep 17 00:00:00 2001 From: "gavinp@google.com" Date: Mon, 9 Aug 2010 18:58:51 +0000 Subject: Histograms & Field Trails about prefetching This CL lands some histograms to track prefetching, and a 10% field trial enabling the feature to track performance. BUG=none TEST=none Review URL: http://codereview.chromium.org/3036050 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@55431 0039d316-1c4b-4281-b951-d872f2087c98 --- chrome/renderer/navigation_state.h | 18 ++++++- chrome/renderer/render_view.cc | 99 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 111 insertions(+), 6 deletions(-) (limited to 'chrome/renderer') diff --git a/chrome/renderer/navigation_state.h b/chrome/renderer/navigation_state.h index 7fa0505..afdebb8 100644 --- a/chrome/renderer/navigation_state.h +++ b/chrome/renderer/navigation_state.h @@ -240,6 +240,16 @@ class NavigationState : public WebKit::WebDataSource::ExtraData { void set_was_translated(bool value) { was_translated_ = value; } bool was_translated() const { return was_translated_; } + void set_was_prefetcher(bool value) { was_prefetcher_ = value; } + bool was_prefetcher() const { return was_prefetcher_; } + + void set_was_referred_by_prefetcher(bool value) { + was_referred_by_prefetcher_ = value; + } + bool was_referred_by_prefetcher() const { + return was_referred_by_prefetcher_; + } + private: NavigationState(PageTransition::Type transition_type, const base::Time& request_time, @@ -262,7 +272,9 @@ class NavigationState : public WebKit::WebDataSource::ExtraData { was_npn_negotiated_(false), was_alternate_protocol_available_(false), was_fetched_via_proxy_(false), - was_translated_(false) { + was_translated_(false), + was_prefetcher_(false), + was_referred_by_prefetcher_(false) { } PageTransition::Type transition_type_; @@ -298,6 +310,10 @@ class NavigationState : public WebKit::WebDataSource::ExtraData { bool was_fetched_via_proxy_; bool was_translated_; + // A prefetcher is a page that contains link rel=prefetch elements. + bool was_prefetcher_; + bool was_referred_by_prefetcher_; + DISALLOW_COPY_AND_ASSIGN(NavigationState); }; diff --git a/chrome/renderer/render_view.cc b/chrome/renderer/render_view.cc index bc400ef..e92fc2a 100644 --- a/chrome/renderer/render_view.cc +++ b/chrome/renderer/render_view.cc @@ -538,7 +538,7 @@ void RenderView::SetNextPageID(int32 next_page_id) { next_page_id_ = next_page_id; } -WebKit::WebView* RenderView::webview() const{ +WebKit::WebView* RenderView::webview() const { return static_cast(webwidget()); } @@ -2643,8 +2643,37 @@ void RenderView::didCreateDataSource(WebFrame* frame, WebDataSource* ds) { NavigationState* state = content_initiated ? NavigationState::CreateContentInitiated() : pending_navigation_state_.release(); + + const WebURLRequest& original_request = ds->originalRequest(); + const WebURLRequest& request = ds->request(); + + // NavigationState::referred_by_prefetcher_ is true if we are + // navigating from a page that used prefetching using a link on that + // page. We are early enough in the request process here that we + // can still see the NavigationState of the previous page and set + // this value appropriately. + // TODO(gavinp): catch the important case of navigation in a new + // renderer process. + if (webview()) { + if( WebFrame* old_frame = webview()->mainFrame()) { + const GURL referrer( + original_request.httpHeaderField(WebString::fromUTF8("Referer"))); + if (!referrer.is_empty() && + NavigationState::FromDataSource( + old_frame->dataSource())->was_prefetcher()) { + for (;old_frame;old_frame = old_frame->traverseNext(false)) { + WebDataSource* old_frame_ds = old_frame->dataSource(); + if (old_frame_ds && referrer == GURL(old_frame_ds->request().url())) { + state->set_was_referred_by_prefetcher(true); + break; + } + } + } + } + } + if (content_initiated) { - switch (ds->request().cachePolicy()) { + switch (request.cachePolicy()) { case WebURLRequest::UseProtocolCachePolicy: // normal load. state->set_load_type(NavigationState::LINK_LOAD_NORMAL); break; @@ -3020,14 +3049,22 @@ void RenderView::willSendRequest( WebFrame* top_frame = frame->top(); if (!top_frame) top_frame = frame; - WebDataSource* data_source = top_frame->provisionalDataSource(); - if (!data_source) - data_source = top_frame->dataSource(); + WebDataSource* provisional_data_source = top_frame->provisionalDataSource(); + WebDataSource* top_data_source = top_frame->dataSource(); + WebDataSource* data_source = + provisional_data_source ? provisional_data_source : top_data_source; if (data_source) { NavigationState* state = NavigationState::FromDataSource(data_source); if (state && state->is_cache_policy_override_set()) request.setCachePolicy(state->cache_policy_override()); } + + if (top_data_source) { + NavigationState* state = NavigationState::FromDataSource(top_data_source); + if (state && request.targetType() == WebURLRequest::TargetIsPrefetch) + state->set_was_prefetcher(true); + } + request.setRequestorID(routing_id_); if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoReferrers)) request.clearHTTPHeaderField("Referer"); @@ -4707,6 +4744,58 @@ void RenderView::DumpLoadHistograms() const { } } + // Histograms to determine if content prefetching has an impact on PLT. + static const bool prefetching_fieldtrial = + FieldTrialList::Find("Prefetch") && + !FieldTrialList::Find("Prefetch")->group_name().empty(); + static const bool prefetching_explicitly_disabled = + CommandLine::ForCurrentProcess()->HasSwitch( + switches::kDisableContentPrefetch); + if (navigation_state->was_prefetcher()) { + if (!prefetching_explicitly_disabled) { + PLT_HISTOGRAM("PLT.BeginToFinishDoc_ContentPrefetcher", + begin_to_finish_doc); + PLT_HISTOGRAM("PLT.BeginToFinish_ContentPrefetcher", + begin_to_finish); + } + if (prefetching_fieldtrial) { + PLT_HISTOGRAM( + FieldTrial::MakeName("PLT.BeginToFinishDoc_ContentPrefetcher", + "Prefetch"), + begin_to_finish_doc); + PLT_HISTOGRAM( + FieldTrial::MakeName("PLT.BeginToFinish_ContentPrefetcher", + "Prefetch"), + begin_to_finish); + } + } + if (navigation_state->was_referred_by_prefetcher()) { + if (!prefetching_explicitly_disabled) { + PLT_HISTOGRAM("PLT.BeginToFinishDoc_ContentPrefetcherReferrer", + begin_to_finish_doc); + PLT_HISTOGRAM("PLT.BeginToFinish_ContentPrefetcherReferrer", + begin_to_finish); + } + if (prefetching_fieldtrial) { + PLT_HISTOGRAM( + FieldTrial::MakeName("PLT.BeginToFinishDoc_ContentPrefetcherReferrer", + "Prefetch"), + begin_to_finish_doc); + PLT_HISTOGRAM( + FieldTrial::MakeName("PLT.BeginToFinish_ContentPrefetcherReferrer", + "Prefetch"), + begin_to_finish); + } + } + if (prefetching_fieldtrial) { + UMA_HISTOGRAM_ENUMERATION(FieldTrial::MakeName("PLT.Abandoned", "Prefetch"), + abandoned_page ? 1 : 0, 2); + PLT_HISTOGRAM(FieldTrial::MakeName("PLT.BeginToFinishDoc", "Prefetch"), + begin_to_finish_doc); + PLT_HISTOGRAM(FieldTrial::MakeName("PLT.BeginToFinish", "Prefetch"), + begin_to_finish); + } + // Histograms to determine if the number of connections has an // impact on PLT. // TODO(jar): Consider removing the per-link-type versions. We -- cgit v1.1