Improve blacklist logic: use more fields (driver_vendor, gl_renderer, ect) fo...

chrome/browser/gpu_process_host.cc

 // Copyright (c) 2010 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/gpu_process_host.h"
 
 #include "app/app_switches.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/string_piece.h"
@@ skipping 10 matching lines @@
 #include "chrome/common/render_messages.h"
 #include "chrome/gpu/gpu_thread.h"
 #include "grit/browser_resources.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace {
 
-enum GPUBlacklistTestResult {
-  BLOCKED,
-  ALLOWED,
-  BLACKLIST_TEST_RESULT_MAX
-};
-
 enum GPUProcessLifetimeEvent {
   LAUNCED,
   CRASHED,
   GPU_PROCESS_LIFETIME_EVENT_MAX
   };
 
 // Tasks used by this file
 class RouteOnUIThreadTask : public Task {
  public:
   explicit RouteOnUIThreadTask(const IPC::Message& msg) : msg_(msg) {
@@ skipping 52 matching lines @@
  private:
   scoped_ptr<GpuThread> gpu_thread_;
   std::string channel_id_;
   DISALLOW_COPY_AND_ASSIGN(GpuMainThread);
 };
 
 GpuProcessHost::GpuProcessHost()
     : BrowserChildProcessHost(GPU_PROCESS, NULL),
       initialized_(false),
       initialized_successfully_(false),
-      blacklist_result_recorded_(false) {
+      gpu_feature_flags_set_(false) {
   DCHECK_EQ(sole_instance_, static_cast<GpuProcessHost*>(NULL));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   while (!queued_synchronization_replies_.empty()) {
     delete queued_synchronization_replies_.front().reply;
     queued_synchronization_replies_.pop();
   }
   DCHECK_EQ(sole_instance_, this);
   sole_instance_ = NULL;
@@ skipping 99 matching lines @@
     // handle it.
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle,
     const GPUInfo& gpu_info) {
-  GpuFeatureFlags gpu_feature_flags;
-  if (channel_handle.name.size() != 0) {
-    gpu_feature_flags = gpu_blacklist_->DetermineGpuFeatureFlags(
+  if (channel_handle.name.size() != 0 && !gpu_feature_flags_set_) {
+    gpu_feature_flags_ = gpu_blacklist_->DetermineGpuFeatureFlags(
         GpuBlacklist::kOsAny, NULL, gpu_info);
+    gpu_feature_flags_set_ = true;
+    uint32 max_entry_id = gpu_blacklist_->max_entry_id();
+    if (gpu_feature_flags_.flags() != 0) {
+      std::vector<uint32> flag_entries;
+      gpu_blacklist_->GetGpuFeatureFlagEntries(GpuFeatureFlags::kGpuFeatureAll,
+                                               flag_entries);
+      DCHECK_GT(flag_entries.size(), 0u);
+      for (size_t i = 0; i < flag_entries.size(); ++i) {
+        UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
+                                  flag_entries[i], max_entry_id + 1);
+      }
+    } else {
+      // id 0 is never used by any entry, so we use it here to indicate that
+      // gpu is allowed.
+      UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
+                                0, max_entry_id + 1);
+    }
   }
   const ChannelRequest& request = sent_requests_.front();
   // Currently if any of the GPU features are blacklised, we don't establish a
   // GPU channel.
-  GPUBlacklistTestResult test_result;
-  if (gpu_feature_flags.flags() != 0) {
+  if (gpu_feature_flags_.flags() != 0) {
     Send(new GpuMsg_CloseChannel(channel_handle));
     SendEstablishChannelReply(IPC::ChannelHandle(), gpu_info, request.filter);
-    test_result = BLOCKED;
   } else {
     SendEstablishChannelReply(channel_handle, gpu_info, request.filter);
-    test_result = ALLOWED;
-  }
-  if (!blacklist_result_recorded_) {
-    UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResults",
-                              test_result, BLACKLIST_TEST_RESULT_MAX);
-    blacklist_result_recorded_ = true;
   }
   sent_requests_.pop();
 }
 
 void GpuProcessHost::OnSynchronizeReply() {
   // Guard against race conditions in abrupt GPU process termination.
   if (queued_synchronization_replies_.size() > 0) {
     const SynchronizationRequest& request =
         queued_synchronization_replies_.front();
     SendSynchronizationReply(request.reply, request.filter);
@@ skipping 140 matching lines @@
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) ||
       blacklist->LoadGpuBlacklist(gpu_blacklist_json.as_string(), true)) {
     gpu_blacklist_.reset(blacklist);
     return true;
   }
   delete blacklist;
   return false;
 }