Add UMA histograms for GPU driver bug workaround entries.

content/browser/gpu/gpu_data_manager_impl_private.cc

 // Copyright (c) 2013 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 "content/browser/gpu/gpu_data_manager_impl_private.h"
 
 #include <algorithm>
 #include <iterator>
 #include <memory>
 #include <utility>
@@ skipping 191 matching lines @@
     histogram_pointer = base::LinearHistogram::FactoryGet(
         kGpuBlacklistFeatureHistogramNamesWin[i], 1,
         kNumWinSubVersions * gpu::kGpuFeatureStatusMax,
         kNumWinSubVersions * gpu::kGpuFeatureStatusMax + 1,
         base::HistogramBase::kUmaTargetedHistogramFlag);
     histogram_pointer->Add(GetGpuBlacklistHistogramValueWin(value));
 #endif
   }
 }
 
+void UpdateDriverBugListStats(const gpu::GpuDriverBugList* bug_list,
+                              const std::set<int>& workarounds) {
+  uint32_t max_entry_id = bug_list->max_entry_id();
+  if (max_entry_id == 0) {
+    // Driver bug list was not loaded.  No need to go further.
+    return;
+  }
+
+  // Use entry 0 to capture the total number of times that data was recorded
+  // in this histogram in order to have a convenient denominator to compute
+  // driver bug list percentages for the rest of the entries.
+  UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.DriverBugTestResultsPerEntry", 0);
+
+  if (workarounds.size() != 0) {
+    std::vector<uint32_t> flag_entries;
+    bug_list->GetDecisionEntries(&flag_entries);

[Ilya Sherman, 2017/05/04 21:17:38]

It's not entirely clear to me: Are the ids used in the bug list intended to be
time-invariant identifiers?  That is, is it already expected that the value "54"
will always mean the same thing, no matter which version of Chrome is reporting
the bug ids?  If so, great.  If not, you'll want to ensure that the ids recorded
to histograms have consistent semantics over time -- either by making the bug
list restrictions more rigid, or by providing some translation code to map to a
separate set of rigid ids.

+    DCHECK_GT(flag_entries.size(), 0u);
+    for (size_t i = 0; i < flag_entries.size(); ++i) {
+      UMA_HISTOGRAM_SPARSE_SLOWLY("GPU.DriverBugTestResultsPerEntry",
+                                  flag_entries[i]);
+    }
+  }
+}
+
 // Combine the integers into a string, seperated by ','.
 std::string IntSetToString(const std::set<int>& list) {
   std::string rt;
   for (std::set<int>::const_iterator it = list.begin();
        it != list.end(); ++it) {
     if (!rt.empty())
       rt += ",";
     rt += base::IntToString(*it);
   }
   return rt;
@@ skipping 456 matching lines @@
                             disabled_command_line_exts.end());
   }
 
   if (gpu_driver_bug_list_) {
     gpu_driver_bugs_ = gpu_driver_bug_list_->MakeDecision(
         gpu::GpuControlList::kOsAny, os_version, gpu_info_);
 
     disabled_driver_bug_exts = gpu_driver_bug_list_->GetDisabledExtensions();
     disabled_ext_set.insert(disabled_driver_bug_exts.begin(),
                             disabled_driver_bug_exts.end());
+    UpdateDriverBugListStats(gpu_driver_bug_list_.get(), gpu_driver_bugs_);
   }
   disabled_extensions_ =
       base::JoinString(std::vector<base::StringPiece>(disabled_ext_set.begin(),
                                                       disabled_ext_set.end()),
                        " ");
 
   gpu::GpuDriverBugList::AppendWorkaroundsFromCommandLine(
       &gpu_driver_bugs_, *base::CommandLine::ForCurrentProcess());
 
   // We have to update GpuFeatureType before notify all the observers.
@@ skipping 686 matching lines @@
   gpu_info_.context_info_state = gpu::kCollectInfoFatalFailure;
 #if defined(OS_WIN)
   gpu_info_.dx_diagnostics_info_state = gpu::kCollectInfoFatalFailure;
 #endif
   complete_gpu_info_already_requested_ = true;
   // Some observers might be waiting.
   NotifyGpuInfoUpdate();
 }
 
 }  // namespace content