Display histograms from subprocesses in chrome://histograms

chrome/browser/metrics/subprocess_metrics_provider.h

 // 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.
 
 #ifndef CHROME_BROWSER_METRICS_SUBPROCESS_METRICS_PROVIDER_H_
 #define CHROME_BROWSER_METRICS_SUBPROCESS_METRICS_PROVIDER_H_
 
+#include <map>
 #include <memory>
-#include <set>
+#include <vector>
 
 #include "base/gtest_prod_util.h"
-#include "base/id_map.h"
+#include "base/metrics/statistics_recorder.h"
 #include "base/scoped_observer.h"
-#include "base/threading/thread_checker.h"
+#include "base/synchronization/lock.h"
 #include "components/metrics/metrics_provider.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_process_host_observer.h"
 
 namespace base {
 class PersistentHistogramAllocator;
 class SharedPersistentMemoryAllocator;
 }
 
 // SubprocessMetricsProvider gathers and logs histograms stored in shared
 // memory segments between processes.
-class SubprocessMetricsProvider : public metrics::MetricsProvider,
-                                  public content::NotificationObserver,
-                                  public content::RenderProcessHostObserver {
+class SubprocessMetricsProvider
+    : public metrics::MetricsProvider,
+      public base::StatisticsRecorder::MetricsDisplay,
+      public content::NotificationObserver,
+      public content::RenderProcessHostObserver {
  public:
   SubprocessMetricsProvider();
   ~SubprocessMetricsProvider() override;
 
  private:
   friend class SubprocessMetricsProviderTest;
 
   // Indicates subprocess to be monitored with unique id for later reference.
   // Metrics reporting will read histograms from it and upload them to UMA.
   void RegisterSubprocessAllocator(
       int id,
       std::unique_ptr<base::PersistentHistogramAllocator> allocator);
 
   // Indicates that a subprocess has exited and is thus finished with the
   // allocator it was using.
   void DeregisterSubprocessAllocator(int id);
 
-  // Report all histograms of a given allocator to the snapshot-manager.
+  // Report histograms of a given allocator to the snapshot-manager. If
+  // |query| is not empty, only histograms that contain that string will
+  // be recorded. If |absolute| is true, no delta from the previous snapshot
+  // will be done. Only one caller, the caller that uploads to UMA, is
+  // allowed to calcuate deltas because they are not independent.
   void RecordHistogramSnapshotsFromAllocator(
       base::HistogramSnapshotManager* snapshot_manager,
+      const std::string& query,
+      bool absolute,
       int id,
       base::PersistentHistogramAllocator* allocator);
 
   // metrics::MetricsProvider:
   void OnRecordingEnabled() override;
   void OnRecordingDisabled() override;
   void RecordHistogramSnapshots(
       base::HistogramSnapshotManager* snapshot_manager) override;
 
+  // base::StatisticsRecorder::MetricsDisplay:
+  void WriteTitleString(std::string* output) override;
+  void WriteGraphs(const std::string& query,
+                   bool html,
+                   std::string* output) override;
+
   // content::NotificationObserver:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // content::RenderProcessHostObserver:
   void RenderProcessReady(content::RenderProcessHost* host) override;
   void RenderProcessExited(content::RenderProcessHost* host,
                            base::TerminationStatus status,
                            int exit_code) override;
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
 
-  base::ThreadChecker thread_checker_;
+  // Lock for accessing objects. This is required because MetricsDisplay is
+  // typically called by a background thread.

[Ilya Sherman, 2016/04/13 00:29:32]

Hmm, why so?  I would have expected it to be called from the main thread.  Could
the messages from background threads instead be bounced to the main thread?

[bcwhite, 2016/04/13 11:58:18]

The previous code broke because it was called on a different thread.  I didn't
investigate.  I assume that it's merely being collected in the background for
sending to the renderer process for display.

I considered bouncing but it seemed an overly complex solution.  Acquiring the
lock is something that happens relatively infrequently.  Also, generating all
these histogram graphs could take significant time so probably best if it's not
on the UI thread.

I can reduce the amount of time for which the lock is held, however.

+  base::Lock lock_;
 
   // Object for registing notification requests.
   content::NotificationRegistrar registrar_;
 
   // All of the shared-persistent-allocators for known sub-processes.
   using AllocatorByIdMap =
-      IDMap<base::PersistentHistogramAllocator, IDMapOwnPointer, int>;
+      std::map<int, std::unique_ptr<base::PersistentHistogramAllocator>>;
   AllocatorByIdMap allocators_by_id_;
 
   // Allocators that are no longer attached to a subprocess, to be released
   // once the last data contained therein has been reported.
   std::vector<std::unique_ptr<base::PersistentHistogramAllocator>>
       allocators_to_release_;
 
   // Track all observed render processes to un-observe them on exit.
   ScopedObserver<content::RenderProcessHost, SubprocessMetricsProvider>
       scoped_observer_;
 
   // Flag indicating if metrics recording is enabled. Allocators will not
   // live past the death of the subprocess if it is not.
   bool metrics_recording_enabled_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(SubprocessMetricsProvider);
 };
 
 #endif  // CHROME_BROWSER_METRICS_SUBPROCESS_METRICS_PROVIDER_H_