Add V8 heap statistics in a time-line manner in tracing.

chrome/renderer/chrome_render_process_observer.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/renderer/chrome_render_process_observer.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/variations/variations_util.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/extensions/extension_localization_peer.h"
 #include "chrome/renderer/security_filter_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/render_view_visitor.h"
+#include "content/public/renderer/v8_heap_statistics_collector.h"
 #include "crypto/nss_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_module.h"
 #include "third_party/WebKit/public/web/WebCache.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
@@ skipping 91 matching lines @@
       std::vector<char> font_data;
       RenderThread::Get()->PreCacheFont(logfont);
       rv = GetFontData(hdc, table, offset, buffer, length);
       RenderThread::Get()->ReleaseCachedFonts();
     }
   }
   return rv;
 }
 #endif  // OS_WIN
 
-static const int kWaitForWorkersStatsTimeoutMS = 20;
-
-class HeapStatisticsCollector {
- public:
-  HeapStatisticsCollector() : round_id_(0) {}
-
-  void InitiateCollection();
-  static HeapStatisticsCollector* Instance();
-
- private:
-  void CollectOnWorkerThread(scoped_refptr<base::TaskRunner> master,
-                             int round_id);
-  void ReceiveStats(int round_id, size_t total_size, size_t used_size);
-  void SendStatsToBrowser(int round_id);
-
-  size_t total_bytes_;
-  size_t used_bytes_;
-  int workers_to_go_;
-  int round_id_;
-};
-
-HeapStatisticsCollector* HeapStatisticsCollector::Instance() {
-  CR_DEFINE_STATIC_LOCAL(HeapStatisticsCollector, instance, ());
-  return &instance;
-}
-
-void HeapStatisticsCollector::InitiateCollection() {
-  v8::HeapStatistics heap_stats;
-  v8::Isolate::GetCurrent()->GetHeapStatistics(&heap_stats);
-  total_bytes_ = heap_stats.total_heap_size();
-  used_bytes_ = heap_stats.used_heap_size();
-  base::Closure collect = base::Bind(
-      &HeapStatisticsCollector::CollectOnWorkerThread,
-      base::Unretained(this),
-      base::MessageLoopProxy::current(),
-      round_id_);
-  workers_to_go_ = RenderThread::Get()->PostTaskToAllWebWorkers(collect);
-  if (workers_to_go_) {
-    // The guard task to send out partial stats
-    // in case some workers are not responsive.
-    base::MessageLoopProxy::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&HeapStatisticsCollector::SendStatsToBrowser,
-                   base::Unretained(this),
-                   round_id_),
-        base::TimeDelta::FromMilliseconds(kWaitForWorkersStatsTimeoutMS));
-  } else {
-    // No worker threads so just send out the main thread data right away.
-    SendStatsToBrowser(round_id_);
-  }
-}
-
-void HeapStatisticsCollector::CollectOnWorkerThread(
-    scoped_refptr<base::TaskRunner> master,
-    int round_id) {
-
-  size_t total_bytes = 0;
-  size_t used_bytes = 0;
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  if (isolate) {
-    v8::HeapStatistics heap_stats;
-    isolate->GetHeapStatistics(&heap_stats);
-    total_bytes = heap_stats.total_heap_size();
-    used_bytes = heap_stats.used_heap_size();
-  }
-  master->PostTask(
-      FROM_HERE,
-      base::Bind(&HeapStatisticsCollector::ReceiveStats,
-                 base::Unretained(this),
-                 round_id,
-                 total_bytes,
-                 used_bytes));
-}
-
-void HeapStatisticsCollector::ReceiveStats(int round_id,
-                                           size_t total_bytes,
-                                           size_t used_bytes) {
-  if (round_id != round_id_)
-    return;
-  total_bytes_ += total_bytes;
-  used_bytes_ += used_bytes;
-  if (!--workers_to_go_)
-    SendStatsToBrowser(round_id);
-}
-
-void HeapStatisticsCollector::SendStatsToBrowser(int round_id) {
-  if (round_id != round_id_)
-    return;
-  // TODO(alph): Do caching heap stats and use the cache if we haven't got
-  //             reply from a worker.
-  //             Currently a busy worker stats are not counted.
-  RenderThread::Get()->Send(new ChromeViewHostMsg_V8HeapStats(
-      total_bytes_, used_bytes_));
-  ++round_id_;
-}
-
 }  // namespace
 
 bool ChromeRenderProcessObserver::is_incognito_process_ = false;
 
 ChromeRenderProcessObserver::ChromeRenderProcessObserver(
     ChromeContentRendererClient* client)
     : client_(client),
       clear_cache_pending_(false),
       webkit_initialized_(false),
       pending_cache_min_dead_capacity_(0),
@@ skipping 138 matching lines @@
   base::FieldTrial* trial =
       base::FieldTrialList::CreateFieldTrial(field_trial_name, group_name);
   // TODO(mef): Remove this check after the investigation of 359406 is complete.
   CHECK(trial) << field_trial_name << ":" << group_name;
   // Ensure the trial is marked as "used" by calling group() on it. This is
   // needed to ensure the trial is properly reported in renderer crash reports.
   trial->group();
   chrome_variations::SetChildProcessLoggingVariationList();
 }
 
+namespace {
+
+void OnV8HeapStatsCollected(
+      const content::V8HeapStatisticsCollector::Statistics& stats) {
+  RenderThread::Get()->Send(new ChromeViewHostMsg_V8HeapStats(
+      stats.total_bytes, stats.used_bytes));
+}
+
+} // namespace
+
 void ChromeRenderProcessObserver::OnGetV8HeapStats() {
-  HeapStatisticsCollector::Instance()->InitiateCollection();
+  content::V8HeapStatisticsCollector::Instance()->InitiateCollection(
+      base::Bind(OnV8HeapStatsCollected));
 }
 
 void ChromeRenderProcessObserver::ExecutePendingClearCache() {
   if (clear_cache_pending_ && webkit_initialized_) {
     clear_cache_pending_ = false;
     WebCache::clear();
   }
 }
 
 const RendererContentSettingRules*
 ChromeRenderProcessObserver::content_setting_rules() const {
   return &content_setting_rules_;
 }