Create and pass shared-histogram-allocator from browser to renderer.

chrome/browser/metrics/subprocess_metrics_provider.cc

+// Copyright 2016 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/metrics/subprocess_metrics_provider.h"
+
+#include "base/logging.h"
+#include "base/metrics/histogram_base.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/metrics/persistent_histogram_allocator.h"
+#include "base/metrics/persistent_memory_allocator.h"
+#include "components/metrics/metrics_service.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+
+SubprocessMetricsProvider::SubprocessMetricsProvider()
+    : scoped_observer_(this) {
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+}
+
+SubprocessMetricsProvider::~SubprocessMetricsProvider() {}
+
+void SubprocessMetricsProvider::RegisterSubprocessAllocator(
+    int id,
+    scoped_ptr<base::PersistentHistogramAllocator> allocator) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!allocators_by_id_.Lookup(id));
+
+  // Map is "MapOwnPointer" so transfer ownership to it.
+  allocators_by_id_.AddWithID(allocator.release(), id);
+}
+
+void SubprocessMetricsProvider::DeregisterSubprocessAllocator(int id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!allocators_by_id_.Lookup(id))
+    return;
+
+  // Extract the matching allocator from the list of active ones.
+  scoped_ptr<base::PersistentHistogramAllocator> allocator(
+      allocators_by_id_.Replace(id, nullptr));
+  allocators_by_id_.Remove(id);
+  DCHECK(allocator);
+
+  // If metrics recording is enabled, transfer the allocator to the "release"
+  // list. The allocator will continue to live (and keep the associated shared
+  // memory alive) until the next upload after which it will be released.
+  // Otherwise, the allocator and its memory will be released when the
+  // scoped_ptr goes out of scope at the end of this method.
+  if (metrics_recording_enabled_)
+    allocators_to_release_.push_back(std::move(allocator));
+}
+
+void SubprocessMetricsProvider::OnRecordingEnabled() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  metrics_recording_enabled_ = true;
+}
+
+void SubprocessMetricsProvider::OnRecordingDisabled() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  metrics_recording_enabled_ = false;
+  allocators_to_release_.clear();
+}
+
+void SubprocessMetricsProvider::RecordHistogramSnapshotsFromAllocator(
+    base::HistogramSnapshotManager* snapshot_manager,
+    int id,
+    base::PersistentHistogramAllocator* allocator) {
+  DCHECK(allocator);
+
+  int histogram_count = 0;
+  base::PersistentHistogramAllocator::Iterator hist_iter;
+  allocator->CreateIterator(&hist_iter);
+  while (true) {
+    scoped_ptr<base::HistogramBase> histogram =
+        allocator->GetNextHistogram(&hist_iter);
+    if (!histogram)
+      break;
+    snapshot_manager->PrepareDeltaTakingOwnership(std::move(histogram));
+    ++histogram_count;
+  }
+
+  DVLOG(1) << "Reported " << histogram_count << " histograms from subprocess #"
+           << id;
+}
+
+void SubprocessMetricsProvider::RecordHistogramSnapshots(
+    base::HistogramSnapshotManager* snapshot_manager) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  for (AllocatorByIdMap::iterator iter(&allocators_by_id_); !iter.IsAtEnd();
+       iter.Advance()) {
+    RecordHistogramSnapshotsFromAllocator(
+        snapshot_manager, iter.GetCurrentKey(), iter.GetCurrentValue());
+  }
+
+  for (auto& allocator : allocators_to_release_)
+    RecordHistogramSnapshotsFromAllocator(snapshot_manager, 0, allocator.get());
+
+  UMA_HISTOGRAM_COUNTS_100(
+      "UMA.SubprocessMetricsProvider.SubproccessCount",
+      allocators_by_id_.size() + allocators_to_release_.size());
+
+  // The snapshot-manager has taken ownership of the histograms but needs
+  // access to only the histogram objects, not "sample" data it uses. Thus,
+  // it is safe to release shared-memory segments without waiting for the
+  // snapshot-manager to "finish".
+  allocators_to_release_.clear();
+}
+
+void SubprocessMetricsProvider::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_EQ(content::NOTIFICATION_RENDERER_PROCESS_CREATED, type);
+
+  content::RenderProcessHost* host =
+      content::Source<content::RenderProcessHost>(source).ptr();
+
+  // Sometimes, the same host will cause multiple notifications in tests so
+  // could possibly do the same in a release build.
+  if (!scoped_observer_.IsObserving(host))
+    scoped_observer_.Add(host);
+}
+
+void SubprocessMetricsProvider::RenderProcessReady(
+    content::RenderProcessHost* host) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If the render-process-host passed a persistent-memory-allocator to the
+  // renderer process, extract it and register it here.
+  scoped_ptr<base::SharedPersistentMemoryAllocator> allocator =
+      host->ExtractMetricsAllocator();
+  if (allocator) {
+    RegisterSubprocessAllocator(
+        host->GetID(),
+        make_scoped_ptr(new base::PersistentHistogramAllocator(
+            std::move(allocator))));
+  }
+}
+
+void SubprocessMetricsProvider::RenderProcessHostDestroyed(
+    content::RenderProcessHost* host) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  DeregisterSubprocessAllocator(host->GetID());

[grt (UTC plus 2), 2016/04/01 14:22:48]

since RegisterSubprocessAllocator happens once the subprocess has spun up (in
RenderProcessReady), the symmetrical place to Deregister seems to be in
RenderProcessExited rather than RenderProcessHostDestroyed. in particular, the
doc comment on RenderProcessExited leads me to believe that another sub-process
could be spun up for the same RPH, in which case you'd currently handle more
than one "Ready" call where you register multiple times with the same ID.

[bcwhite, 2016/04/01 16:50:26]

I had that originally but there are cases where a renderer would terminate but
not perform that callback whereas Destroyed is always called.  Perhaps the best
choice is to respond to both; the code is already tolerant if trying to
deregister something that isn't known.

+  scoped_observer_.Remove(host);
+}