Adding histograms showing fraction of page load times

chrome/browser/net/cache_stats.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/net/cache_stats.h"
+
+#include <vector>
+
+#include "base/hash_tables.h"
+#include "base/metrics/histogram.h"
+#include "base/stl_util.h"
+#include "base/string_number_conversions.h"
+#include "base/timer.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
+#include "content/common/view_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/resource_request_info.h"
+#include "content/public/browser/web_contents.h"
+#include "net/url_request/url_request.h"
+
+using content::BrowserThread;
+using content::ResourceRequestInfo;
+using content::RenderViewHost;
+
+#if defined(COMPILER_GCC)
+
+namespace BASE_HASH_NAMESPACE {
+template <>
+struct hash<const net::URLRequest*> {
+  std::size_t operator()(const net::URLRequest* value) const {
+    return reinterpret_cast<std::size_t>(value);
+  }
+};
+}
+
+#endif
+
+namespace chrome_browser_net {
+
+namespace {
+
+bool GetRenderView(const net::URLRequest& request,
+                   int* process_id, int* route_id) {
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(&request);
+  if (!info)
+    return false;
+
+  return info->GetAssociatedRenderView(process_id, route_id);
+}
+
+// Times after a load has started at which stats are collected.
+const int kStatsCollectionTimesMs[] = {
+  500,
+  1000,
+  2000,
+  3000,
+  4000,
+  5000,
+  7500,
+  10000,
+  15000,
+  20000
+};
+
+}  // namespace
+
+// static
+CacheStats* CacheStats::GetInstance() {
+  return Singleton<CacheStats>::get();
+}
+
+struct CacheStats::TabLoadStats {
+  TabLoadStats()
+      : num_active_(0),
+        spinner_started_(false),
+        timer_(false, false) {
+  }
+
+  int num_active_;
+  bool spinner_started_;
+  base::TimeTicks load_start_time_;
+  base::TimeTicks cache_start_time_;
+  base::TimeDelta cache_total_time_;
+  base::Timer timer_;
+  typedef base::hash_map<const net::URLRequest*, int> PerRequestNumActiveMap;
+  PerRequestNumActiveMap per_request_num_active_;

[rvargas (doing something else), 2012/07/23 22:22:36]

This deserves a comment.

[tburkard, 2012/07/24 01:03:12]

Done.

[rvargas (doing something else), 2012/07/26 02:13:43]

I meant the map.

+};
+
+CacheStatsRenderViewHostObserver::CacheStatsRenderViewHostObserver(
+    RenderViewHost* host)
+    : content::RenderViewHostObserver(host),
+      cache_stats_(CacheStats::GetInstance()),
+      is_loading_(false) {
+  int process_id = render_view_host()->GetProcess()->GetID();
+  int route_id = render_view_host()->GetRoutingID();
+  render_view_id_ = std::pair<int, int>(process_id, route_id);
+}
+
+bool CacheStatsRenderViewHostObserver::OnMessageReceived(
+    const IPC::Message& message) {
+  IPC_BEGIN_MESSAGE_MAP(CacheStatsRenderViewHostObserver, message)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidStartProvisionalLoadForFrame,
+                        OnDidStartProvisionalLoadForFrame)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DidStopLoading, OnDidStopLoading)
+  IPC_END_MESSAGE_MAP()
+
+  return false;
+}
+
+void CacheStatsRenderViewHostObserver::OnDidStartProvisionalLoadForFrame(
+    int64 frame_id,
+    bool is_main_frame,
+    const GURL& opener_url,
+    const GURL& url) {
+  if (!is_main_frame)
+    return;
+  if (is_loading_)
+    OnDidStopLoading();
+  if (!url.SchemeIs("http"))
+    return;
+  is_loading_ = true;
+  NotifyCacheStats(CacheStats::SPINNER_START);
+}
+
+void CacheStatsRenderViewHostObserver::OnDidStopLoading() {
+  is_loading_ = false;
+  NotifyCacheStats(CacheStats::SPINNER_STOP);
+}
+
+CacheStatsRenderViewHostObserver::~CacheStatsRenderViewHostObserver() {
+  NotifyCacheStats(CacheStats::RENDERER_DESTROY);
+}
+
+void CacheStatsRenderViewHostObserver::NotifyCacheStats(
+    CacheStats::TabEvent event) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CacheStats::OnTabEvent,
+                 base::Unretained(cache_stats_),
+                 render_view_id_, event));
+}
+
+CacheStats::CacheStats() :
+    registered_message_loop_destruction_observer_(false) {
+  for (int i = 0;
+       i < static_cast<int>(arraysize(kStatsCollectionTimesMs));
+       i++) {
+    final_histograms_.push_back(
+        base::LinearHistogram::FactoryGet(
+            "DiskCache.FractionCacheUseFinalPLT_" +

[rvargas (doing something else), 2012/07/23 22:22:36]

Don't use DiskCache.x here

[tburkard, 2012/07/24 01:03:12]

Done.

+            base::IntToString(kStatsCollectionTimesMs[i]),
+            0, 101, 102, base::Histogram::kUmaTargetedHistogramFlag));
+    intermediate_histograms_.push_back(
+        base::LinearHistogram::FactoryGet(
+            "DiskCache.FractionCacheUseIntermediatePLT_" +
+            base::IntToString(kStatsCollectionTimesMs[i]),
+            0, 101, 102, base::Histogram::kNoFlags));
+  }
+  DCHECK_EQ(final_histograms_.size(), arraysize(kStatsCollectionTimesMs));
+  DCHECK_EQ(intermediate_histograms_.size(),
+            arraysize(kStatsCollectionTimesMs));
+}
+
+CacheStats::~CacheStats() {
+}
+
+void CacheStats::WillDestroyCurrentMessageLoop() {
+  MessageLoop::current()->RemoveDestructionObserver(this);
+  STLDeleteValues(&tab_load_stats_);
+  registered_message_loop_destruction_observer_ = false;
+}
+
+CacheStats::TabLoadStats* CacheStats::GetTabLoadStats(
+    std::pair<int, int> render_view_id) {
+  if (!registered_message_loop_destruction_observer_) {
+    MessageLoop::current()->AddDestructionObserver(this);
+    registered_message_loop_destruction_observer_ = true;
+  }
+  if (tab_load_stats_.count(render_view_id) < 1)
+    tab_load_stats_[render_view_id] = new TabLoadStats();
+  return tab_load_stats_[render_view_id];
+}
+
+void CacheStats::RemoveTabLoadStats(std::pair<int, int> render_view_id) {
+  TabLoadStatsMap::iterator it = tab_load_stats_.find(render_view_id);
+  if (it != tab_load_stats_.end()) {
+    delete it->second;
+    tab_load_stats_.erase(it);
+  }
+}
+
+void CacheStats::OnCacheWaitStateChange(
+    const net::URLRequest& request,
+    net::NetworkDelegate::CacheWaitState state) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  int process_id, route_id;
+  if (!GetRenderView(request, &process_id, &route_id))
+    return;
+  TabLoadStats* stats =
+      GetTabLoadStats(std::pair<int, int>(process_id, route_id));
+  bool newly_started = false;
+  bool newly_finished = false;
+  std::pair<TabLoadStats::PerRequestNumActiveMap::iterator, bool> insert_ret =
+      stats->per_request_num_active_.insert(
+          std::pair<const net::URLRequest*, int>(&request, 0));
+  TabLoadStats::PerRequestNumActiveMap::iterator entry = insert_ret.first;
+  DCHECK_GE(entry->second, 0);
+  switch (state) {
+    case net::NetworkDelegate::CACHE_WAIT_STATE_START:
+      if (entry->second == 0)
+        newly_started = true;
+      entry->second++;

[rvargas (doing something else), 2012/07/23 22:22:36]

Isn't second > 1 a bug?

[tburkard, 2012/07/24 01:03:12]

Not necessarily, you could imagine at some point having two separate cache
actions pending for a given URLRequest at the same time.
On 2012/07/23 22:22:36, rvargas wrote:

[rvargas (doing something else), 2012/07/24 03:10:38]

We should wait until we have the need to support that use case (if ever). At
this point it seems better to detect that as a problem.

[tburkard, 2012/07/24 22:23:26]

Done.

[rvargas (doing something else), 2012/07/26 02:13:43]

Actually, using a boolean is better. In fact, a set instead of a map would be
even better. Right now the code is happy keeping counters up and down except
that there is a dcheck that the counter will never go beyond 1.

[tburkard, 2012/07/26 02:50:54]

Done.

+      break;
+    case net::NetworkDelegate::CACHE_WAIT_STATE_FINISH:
+      if (entry->second > 0) {
+        entry->second--;
+        if (entry->second == 0)
+          newly_finished = true;
+      }
+      break;
+    case net::NetworkDelegate::CACHE_WAIT_STATE_DONE:
+      if (entry->second > 0) {
+        entry->second = 0;
+        newly_finished = true;
+      }
+      break;
+  }
+  DCHECK_GE(entry->second, 0);
+  if (newly_started) {
+    DCHECK(!newly_finished);
+    if (stats->num_active_ == 0) {
+      stats->cache_start_time_ = base::TimeTicks::Now();
+    }
+    stats->num_active_++;
+  }
+  if (newly_finished) {
+    DCHECK(!newly_started);
+    if (stats->num_active_ == 1) {
+      stats->cache_total_time_ +=
+          base::TimeTicks::Now() - stats->cache_start_time_;
+    }
+    stats->num_active_--;
+  }
+}
+
+void CacheStats::OnTabEvent(std::pair<int, int> render_view_id,
+                            TabEvent event) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (event == RENDERER_DESTROY) {
+    RemoveTabLoadStats(render_view_id);
+    return;
+  }
+  TabLoadStats* stats = GetTabLoadStats(render_view_id);
+  if (event == SPINNER_START) {
+    stats->spinner_started_ = true;
+    stats->cache_total_time_ = base::TimeDelta();
+    stats->cache_start_time_ = base::TimeTicks::Now();
+    stats->load_start_time_ = base::TimeTicks::Now();
+    ScheduleTimer(stats, 0);
+  } else {
+    DCHECK_EQ(event, SPINNER_STOP);
+    stats->timer_.Stop();
+    if (stats->spinner_started_) {
+      stats->spinner_started_ = false;
+      base::TimeDelta load_time =
+          base::TimeTicks::Now() - stats->load_start_time_;
+      if (stats->num_active_ > 1)
+        stats->cache_total_time_ +=
+            base::TimeTicks::Now() - stats->cache_start_time_;
+      RecordCacheFractionHistogram(load_time, stats->cache_total_time_, true);
+    }
+    RemoveTabLoadStats(render_view_id);
+  }
+}
+
+void CacheStats::ScheduleTimer(TabLoadStats* stats, int timer_index) {
+  DCHECK(timer_index >= 0 &&
+         timer_index < static_cast<int>(arraysize(kStatsCollectionTimesMs)));
+  base::TimeDelta delta =
+      base::TimeDelta::FromMilliseconds(kStatsCollectionTimesMs[timer_index]);
+  delta -= base::TimeTicks::Now() - stats->load_start_time_;
+  stats->timer_.Start(FROM_HERE,
+                      delta,
+                      base::Bind(&CacheStats::TimerCb,
+                                 base::Unretained(this),
+                                 base::Unretained(stats),
+                                 timer_index));
+}
+
+void CacheStats::TimerCb(TabLoadStats* stats, int timer_index) {
+  DCHECK(stats->spinner_started_);
+  base::TimeDelta load_time = base::TimeTicks::Now() - stats->load_start_time_;
+  base::TimeDelta cache_time = stats->cache_total_time_;
+  if (stats->num_active_ > 1)
+    cache_time += base::TimeTicks::Now() - stats->cache_start_time_;
+  RecordCacheFractionHistogram(load_time, cache_time, false);
+  timer_index++;
+  if (timer_index < static_cast<int>(arraysize(kStatsCollectionTimesMs)))
+    ScheduleTimer(stats, timer_index);
+}
+
+void CacheStats::RecordCacheFractionHistogram(base::TimeDelta elapsed,
+                                              base::TimeDelta cache_time,
+                                              bool is_load_done) {
+  if (elapsed.InMilliseconds() <= 0)
+    return;
+
+  double cache_fraction =

[rvargas (doing something else), 2012/07/23 22:22:36]

This is not needed. TimeXx are 64 bit values.

[tburkard, 2012/07/24 01:03:12]

But if I divide two 64 bit integers, I will get an integer result, which would
be 0, no?  That's why I want to convert to double first?
On 2012/07/23 22:22:36, rvargas wrote:

[rvargas (doing something else), 2012/07/24 03:10:38]

Not if you multiply the numerator by 100 beforehand.

[tburkard, 2012/07/24 22:23:26]

Done.

+      static_cast<double>(cache_time.InMilliseconds()) /
+      static_cast<double>(elapsed.InMilliseconds());
+
+  DCHECK(cache_fraction >= 0.0 && cache_fraction <= 1.0);
+  int cache_fraction_percentage = cache_fraction * 100;
+  DCHECK(cache_fraction_percentage >= 0 && cache_fraction_percentage < 100);
+
+  int index = 0;
+  while (index + 1 < static_cast<int>(arraysize(kStatsCollectionTimesMs)) &&
+         base::TimeDelta::FromMilliseconds(kStatsCollectionTimesMs[index + 1]) <
+         elapsed) {
+    index++;
+  }
+
+  if (is_load_done) {
+    final_histograms_[index]->Add(cache_fraction_percentage);
+  } else {
+    intermediate_histograms_[index]->Add(cache_fraction_percentage);
+  }
+}
+
+}  // namespace chrome_browser_net