Only report exit funnels for canary and dev channels.

components/browser_watcher/watcher_metrics_provider_win.cc

 // Copyright (c) 2014 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 "components/browser_watcher/watcher_metrics_provider_win.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/metrics/sparse_histogram.h"
@@ skipping 127 matching lines @@
     LONG res = regkey.DeleteValue(event_name.c_str());
     if (res != ERROR_SUCCESS) {
       LOG(ERROR) << "Failed to delete value " << event_name;
       return;
     }
   }
 
   events_out->swap(events);
 }
 
-void RecordSingleExitFunnel(base::win::RegKey* parent_key,
-                            const base::char16* name) {
+void MaybeRecordSingleExitFunnel(base::win::RegKey* parent_key,
+                                 const base::char16* name,
+                                 bool report) {
   std::vector<std::pair<base::string16, int64>> events;
   ReadSingleExitFunnel(parent_key, name, &events);
+  if (!report)
+    return;
 
   // Find the earliest event time.
   int64 min_time = std::numeric_limits<int64>::max();
   for (size_t i = 0; i < events.size(); ++i)
     min_time = std::min(min_time, events[i].second);
 
   // Record the exit funnel event times in a sparse stability histogram.
   for (size_t i = 0; i < events.size(); ++i) {
     std::string histogram_name(
         WatcherMetricsProviderWin::kExitFunnelHistogramPrefix);
     histogram_name.append(base::WideToUTF8(events[i].first));
     base::TimeDelta event_time =
         base::Time::FromInternalValue(events[i].second) -
             base::Time::FromInternalValue(min_time);
     base::HistogramBase* histogram =
         base::SparseHistogram::FactoryGet(
             histogram_name.c_str(),
             base::HistogramBase::kUmaStabilityHistogramFlag);
 
     // Record the time rounded up to the nearest millisecond.
     histogram->Add(event_time.InMillisecondsRoundedUp());
   }
 }
 
-void RecordExitFunnels(const base::string16& registry_path) {
+void MaybeRecordExitFunnels(const base::string16& registry_path, bool report) {
   base::win::RegistryKeyIterator it(HKEY_CURRENT_USER, registry_path.c_str());
   if (!it.Valid())
     return;
 
   // Exit early if no work to do.
   if (it.SubkeyCount() == 0)
     return;
 
   // Open the key we use for deletion preemptively to prevent reporting
   // multiple times on permission problems.
   base::win::RegKey key(HKEY_CURRENT_USER,
                         registry_path.c_str(),
                         KEY_QUERY_VALUE);
   if (!key.Valid()) {
     LOG(ERROR) << "Failed to open " << registry_path << " for writing.";
     return;
   }
 
   std::vector<base::string16> to_delete;
   for (; it.Valid(); ++it) {
     // Defer reporting on still-live processes.
     if (IsDeadProcess(it.Name())) {
-      RecordSingleExitFunnel(&key, it.Name());
+      MaybeRecordSingleExitFunnel(&key, it.Name(), report);
       to_delete.push_back(it.Name());
     }
   }
 
   for (size_t i = 0; i < to_delete.size(); ++i) {
     LONG res = key.DeleteEmptyKey(to_delete[i].c_str());
     if (res != ERROR_SUCCESS)
       LOG(ERROR) << "Failed to delete key " << to_delete[i];
   }
 }
 
 }  // namespace
 
 const char WatcherMetricsProviderWin::kBrowserExitCodeHistogramName[] =
     "Stability.BrowserExitCodes";
 const char WatcherMetricsProviderWin::kExitFunnelHistogramPrefix[] =
     "Stability.ExitFunnel.";
 
 WatcherMetricsProviderWin::WatcherMetricsProviderWin(
-    const base::char16* registry_path) : registry_path_(registry_path) {
+    const base::char16* registry_path, bool report_exit_funnels) :
+        registry_path_(registry_path),
+        report_exit_funnels_(report_exit_funnels) {
 }
 
 WatcherMetricsProviderWin::~WatcherMetricsProviderWin() {
 }
 
 void WatcherMetricsProviderWin::ProvideStabilityMetrics(
     metrics::SystemProfileProto* /* system_profile_proto */) {
   // Note that if there are multiple instances of Chrome running in the same
   // user account, there's a small race that will double-report the exit codes
   // from both/multiple instances. This ought to be vanishingly rare and will
   // only manifest as low-level "random" noise. To work around this it would be
   // necessary to implement some form of global locking, which is not worth it
   // here.
   RecordExitCodes(registry_path_);
-  RecordExitFunnels(registry_path_);
+  MaybeRecordExitFunnels(registry_path_, report_exit_funnels_);
 }
 
 }  // namespace browser_watcher