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;
+
+  // Transfer allocator from "active" list to "release" list.
+  allocators_to_release_.push_back(
+      make_scoped_ptr(allocators_by_id_.Replace(id, nullptr)));
+  allocators_by_id_.Remove(id);
+}
+
+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 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());
+  scoped_ptr<base::SharedPersistentMemoryAllocator> allocator =
+      host->ExtractMetricsAllocator();

[Alexei Svitkine (slow), 2016/03/29 17:51:24]

Please add a comment discussing the lifetime of this.

Specifically, what happens when the renderer goes away? Presumably, we still
want to record its metrics for the last time and then throw away the snapshot
and unmap the memory?

Does that happen somewhere?

Also, what is the lifetime of the shared memory? If UMA is disabled, does it get
unmapped at some point - i.e. by some dtor of some scoped ptr - or does it need
to be done explicitly somewhere? Can you expand the CL description to mention
these details?

[bcwhite, 2016/03/30 21:25:55]

Done.  Good point about the UMA not being enabled, though.  Easy fix: just don't
register it and let it be deleted by the scoped_ptr going out-of-scope.

How can I detect, here, if UMA is enabled?

[Alexei Svitkine (slow), 2016/03/31 15:22:04]

You can implement the OnRecordingEnabled() and OnRecordingDisabled() functions
and keep track of the state.

[bcwhite, 2016/03/31 18:27:49]

Done.

+  if (allocator) {
+    RegisterSubprocessAllocator(
+        host->GetID(),
+        make_scoped_ptr(new base::PersistentHistogramAllocator(
+            std::move(allocator))));
+  }
+}
+
+void SubprocessMetricsProvider::RenderProcessHostDestroyed(
+    content::RenderProcessHost* host) {
+  DCHECK(thread_checker_.CalledOnValidThread());

[Alexei Svitkine (slow), 2016/03/29 17:51:24]

Nit: Add an empty line after the DCHECKs at the start of the functions. Here and
in the other ones.

[bcwhite, 2016/03/30 21:25:55]

Done.

+  DeregisterSubprocessAllocator(host->GetID());
+  scoped_observer_.Remove(host);
+}