Report histogram creation results.

base/metrics/histogram_base.cc

 // Copyright (c) 2012 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 "base/metrics/histogram_base.h"
 
 #include <limits.h>
 
 #include <utility>
 
@@ skipping 16 matching lines @@
     case HISTOGRAM:
       return "HISTOGRAM";
     case LINEAR_HISTOGRAM:
       return "LINEAR_HISTOGRAM";
     case BOOLEAN_HISTOGRAM:
       return "BOOLEAN_HISTOGRAM";
     case CUSTOM_HISTOGRAM:
       return "CUSTOM_HISTOGRAM";
     case SPARSE_HISTOGRAM:
       return "SPARSE_HISTOGRAM";
-    default:
-      NOTREACHED();
   }
+  NOTREACHED();
   return "UNKNOWN";
 }
 
 HistogramBase* DeserializeHistogramInfo(PickleIterator* iter) {
   int type;
   if (!iter->ReadInt(&type))
     return NULL;
 
   switch (type) {
     case HISTOGRAM:
       return Histogram::DeserializeInfoImpl(iter);
     case LINEAR_HISTOGRAM:
       return LinearHistogram::DeserializeInfoImpl(iter);
     case BOOLEAN_HISTOGRAM:
       return BooleanHistogram::DeserializeInfoImpl(iter);
     case CUSTOM_HISTOGRAM:
       return CustomHistogram::DeserializeInfoImpl(iter);
     case SPARSE_HISTOGRAM:
       return SparseHistogram::DeserializeInfoImpl(iter);
     default:
       return NULL;
   }
 }
 
 const HistogramBase::Sample HistogramBase::kSampleType_MAX = INT_MAX;
+HistogramBase* HistogramBase::report_histogram_ = nullptr;
 
 HistogramBase::HistogramBase(const std::string& name)
     : histogram_name_(name),
       flags_(kNoFlags) {}
 
 HistogramBase::~HistogramBase() {}
 
 void HistogramBase::CheckName(const StringPiece& name) const {
   DCHECK_EQ(histogram_name(), name);
 }
@@ skipping 40 matching lines @@
   root.SetString("name", histogram_name());
   root.SetInteger("count", count);
   root.SetDouble("sum", static_cast<double>(sum));
   root.SetInteger("flags", flags());
   root.Set("params", std::move(parameters));
   root.Set("buckets", std::move(buckets));
   root.SetInteger("pid", GetCurrentProcId());
   serializer.Serialize(root);
 }
 
+// static
+void HistogramBase::EnableActivityReportHistogram(
+    const std::string& process_type) {
+  DCHECK(!report_histogram_);
+  size_t existing = StatisticsRecorder::GetHistogramCount();
+  if (existing != 0) {
+    DLOG(WARNING) << existing
+                  << " histograms were created before reporting was enabled.";
+  }
+
+  std::string name =
+      "UMA.Histograms.Activity" +
+      (process_type.empty() ? process_type : "." + process_type);
+
+  // Calling FactoryGet() here rather than using a histogram-macro works
+  // around some problems with tests that could end up seeing the results
+  // histogram when not expected due to a bad interaction between
+  // HistogramTester and StatisticsRecorder.
+  report_histogram_ = LinearHistogram::FactoryGet(
+      name, 1, HISTOGRAM_REPORT_MAX, HISTOGRAM_REPORT_MAX + 1,
+      kUmaTargetedHistogramFlag);
+  report_histogram_->Add(HISTOGRAM_REPORT_CREATED);
+}
+
 void HistogramBase::FindAndRunCallback(HistogramBase::Sample sample) const {
   if ((flags() & kCallbackExists) == 0)
     return;
 
   StatisticsRecorder::OnSampleCallback cb =
       StatisticsRecorder::FindCallback(histogram_name());
   if (!cb.is_null())
     cb.Run(sample);
 }
 
@@ skipping 21 matching lines @@
     StringAppendF(&result, "%d", sample);
   return result;
 }
 
 void HistogramBase::WriteAsciiBucketValue(Count current,
                                           double scaled_sum,
                                           std::string* output) const {
   StringAppendF(output, " (%d = %3.1f%%)", current, current/scaled_sum);
 }
 
+// static
+void HistogramBase::ReportHistogramActivity(const HistogramBase& histogram,
+                                            ReportActivity activity) {
+  if (!report_histogram_)
+    return;
+
+  const int32_t flags = histogram.flags_;
+  HistogramReport report_type = HISTOGRAM_REPORT_MAX;
+  switch (activity) {
+    case HISTOGRAM_CREATED:
+      report_histogram_->Add(HISTOGRAM_REPORT_HISTOGRAM_CREATED);
+      switch (histogram.GetHistogramType()) {
+        case HISTOGRAM:
+          report_type = HISTOGRAM_REPORT_TYPE_LOGARITHMIC;
+          break;
+        case LINEAR_HISTOGRAM:
+          report_type = HISTOGRAM_REPORT_TYPE_LINEAR;
+          break;
+        case BOOLEAN_HISTOGRAM:
+          report_type = HISTOGRAM_REPORT_TYPE_BOOLEAN;
+          break;
+        case CUSTOM_HISTOGRAM:
+          report_type = HISTOGRAM_REPORT_TYPE_CUSTOM;
+          break;
+        case SPARSE_HISTOGRAM:
+          report_type = HISTOGRAM_REPORT_TYPE_SPARSE;
+          break;
+      }
+      report_histogram_->Add(report_type);
+      if (flags & kIsPersistent)
+        report_histogram_->Add(HISTOGRAM_REPORT_FLAG_PERSISTENT);
+      if (flags & (kUmaStabilityHistogramFlag & ~kUmaTargetedHistogramFlag))

[grt (UTC plus 2), 2016/03/09 04:04:43]

is the ~kUmaTargetedHistogramFlag necessary? from histogram_base.h, it seems
that the two bits in 0x3 indicate stability, not 0x2 alone. are there any
histograms that have only the 0x2 bit set?

[bcwhite, 2016/03/09 14:01:57]

Yes.  Without it, it will also match those marked UMA_TARGETED because either
bit set alone will cause a non-zero (true) result.
No histograms have only the 0x2 bit set.

[bcwhite, 2016/03/09 14:03:50]

I'll rewrite it to be "(flags & mask) == mask" to be more clear.

[bcwhite, 2016/03/09 16:04:26]

Done.

+        report_histogram_->Add(HISTOGRAM_REPORT_FLAG_UMA_STABILITY);
+      else if (flags & kUmaTargetedHistogramFlag)
+        report_histogram_->Add(HISTOGRAM_REPORT_FLAG_UMA_TARGETED);
+      break;
+
+    case HISTOGRAM_LOOKUP:
+      report_histogram_->Add(HISTOGRAM_REPORT_HISTOGRAM_LOOKUP);
+      break;
+  }
+}
+
 }  // namespace base