Adds UMA metrics for renderer uptime

chrome/browser/metrics/renderer_uptime_metrics_provider.cc

+// Copyright 2017 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/renderer_uptime_metrics_provider.h"
+
+#include <utility>
+
+#include "chrome/browser/metrics/renderer_uptime_tracker.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+#include "extensions/features/features.h"
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+#include "extensions/browser/process_map.h"
+#endif
+
+RendererUptimeMetricsProvider::RendererUptimeMetricsProvider() {}
+
+void RendererUptimeMetricsProvider::OnRecordingEnabled() {
+  if (!RendererUptimeTracker::IsInitialized())
+    RendererUptimeTracker::Initialize();
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,

[Alexei Svitkine (slow), 2017/02/28 16:13:11]

It's strange to use a provider class if you're not overriding any of its
provider interfaces.

Are you only doing this so that this observing would be turned on and off based
on UMA enabled state?

If so, please don't. We specifically do not want to have any performance
optimizations based on UMA state - as this would result in UMA users getting a
worse experience than non-UMA users and would provide an incentive for users to
opt out of UMA, which we do not want to exist.

So, with that in mind, I don't think you need to use the provider class at all.
You just need to always listen for these notifications - which can be done
entirely in RendererUptimeTracker.

[keishi, 2017/03/01 08:09:54]

Done. Removed metric provider class.

FYI: Maybe it has a good reason to, but I copied this code from
ChromeStabilityMetricsProvider::OnRecordingEnabled.

[Alexei Svitkine (slow), 2017/03/01 15:50:18]

Thanks for pointing that out. I filed crbug.com/697461 for us to fix this. One
difference is that code also ends up saving state to prefs - which is awkward
because the code to clear those prefs is the one that actual uploads the log -
so with the current set up they wouldn't be cleared I think. In this case,
you're just using histograms so it doesn't have that concern.

+                 content::NotificationService::AllSources());
+  registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 content::NotificationService::AllSources());
+}
+
+void RendererUptimeMetricsProvider::OnRecordingDisabled() {
+  registrar_.RemoveAll();
+}
+
+void RendererUptimeMetricsProvider::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  switch (type) {
+    case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
+      content::RenderProcessHost* host =
+          content::Source<content::RenderProcessHost>(source).ptr();
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+      if (extensions::ProcessMap::Get(host->GetBrowserContext())
+              ->Contains(host->GetID())) {
+        break;
+      }
+#endif
+      RendererUptimeTracker::Get()->OnRendererStarted(host->GetID());
+      break;
+    }
+
+    case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
+      content::RenderProcessHost* host =
+          content::Source<content::RenderProcessHost>(source).ptr();
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+      if (extensions::ProcessMap::Get(host->GetBrowserContext())
+              ->Contains(host->GetID())) {
+        break;
+      }
+#endif
+      RendererUptimeTracker::Get()->OnRendererTerminated(host->GetID());
+      break;
+    }
+
+    default:
+      NOTREACHED();
+      break;
+  }
+}