Collect as much GPU information as possible without creating a GL/D3D context...

chrome/browser/gpu_process_host_ui_shim.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_ui_shim.h"
 
 #include "app/app_switches.h"
 #include "app/gfx/gl/gl_implementation.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/gpu_blacklist.h"
 #include "chrome/browser/gpu_process_host.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_messages.h"
+#include "chrome/gpu/gpu_info_collector.h"
 #include "grit/browser_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_LINUX)
 // These two #includes need to come after gpu_messages.h.
 #include <gdk/gdkwindow.h>  // NOLINT
 #include <gdk/gdkx.h>  // NOLINT
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/gtk_native_view_id_manager.h"
 #include "ui/gfx/size.h"
@@ skipping 150 matching lines @@
     return OnControlMessageReceived(message);
 
   return router_.RouteMessage(message);
 }
 
 void GpuProcessHostUIShim::EstablishGpuChannel(
     int renderer_id, EstablishChannelCallback *callback) {
   DCHECK(CalledOnValidThread());
   linked_ptr<EstablishChannelCallback> wrapped_callback(callback);
 
+  // If GPU features are already blacklisted, no need to establish the channel.
+  if (EnsureInitialized() && gpu_feature_flags_.flags() != 0) {
+    EstablishChannelError(
+        wrapped_callback.release(), IPC::ChannelHandle(), GPUInfo());
+    return;
+  }
+
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
     channel_requests_.push(wrapped_callback);
   } else {
     EstablishChannelError(
         wrapped_callback.release(), IPC::ChannelHandle(), GPUInfo());
   }
 }
 
 void GpuProcessHostUIShim::Synchronize(SynchronizeCallback* callback) {
   DCHECK(CalledOnValidThread());
@@ skipping 52 matching lines @@
           window, render_view_id, renderer_id, init_params))) {
     create_command_buffer_requests_.push(wrapped_callback);
   } else {
     CreateCommandBufferError(wrapped_callback.release(), MSG_ROUTING_NONE);
   }
 }
 
 void GpuProcessHostUIShim::CollectGraphicsInfoAsynchronously(
     GPUInfo::Level level) {
   DCHECK(CalledOnValidThread());
+  // If GPU is already blacklisted, no more info will be collected.
+  if (gpu_feature_flags_.flags() != 0)
+    return;
   Send(new GpuMsg_CollectGraphicsInfo(level));
 }
 
 void GpuProcessHostUIShim::SendAboutGpuCrash() {
   DCHECK(CalledOnValidThread());
   Send(new GpuMsg_Crash());
 }
 
 void GpuProcessHostUIShim::SendAboutGpuHang() {
   DCHECK(CalledOnValidThread());
@@ skipping 17 matching lines @@
 
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHostUIShim, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished,
                         OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated,
                         OnCommandBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GraphicsInfoCollected,
                         OnGraphicsInfoCollected)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_PreliminaryGraphicsInfoCollected,
+                                    OnPreliminaryGraphicsInfoCollected)
     IPC_MESSAGE_HANDLER(GpuHostMsg_OnLogMessage,
                         OnLogMessage)
     IPC_MESSAGE_HANDLER(GpuHostMsg_SynchronizeReply,
                         OnSynchronizeReply)
 #if defined(OS_LINUX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_ResizeXID, OnResizeXID)
 #elif defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSetIOSurface,
                         OnAcceleratedSurfaceSetIOSurface)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
@@ skipping 102 matching lines @@
     view->DestroyFakePluginWindowHandle(window);
 #elif defined(OS_WIN)
     view->ShowCompositorHostWindow(false);
 #endif
   }
 #endif  // defined(OS_MACOSX) || defined(OS_WIN)
 }
 
 void GpuProcessHostUIShim::OnGraphicsInfoCollected(const GPUInfo& gpu_info) {
   gpu_info_ = gpu_info;
-  child_process_logging::SetGpuInfo(gpu_info);
+  if (gpu_feature_flags_.flags() != 0)
+    gpu_info_.SetLevel(GPUInfo::kComplete);
+  child_process_logging::SetGpuInfo(gpu_info_);
 
   // Used only in testing.
   if (gpu_info_collected_callback_.get())
     gpu_info_collected_callback_->Run();
 }
 
+void GpuProcessHostUIShim::OnPreliminaryGraphicsInfoCollected(
+    const GPUInfo& gpu_info, IPC::Message* reply_msg) {
+  bool blacklisted = false;
+  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
+  if (!browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) &&
+      browser_command_line.GetSwitchValueASCII(
+          switches::kUseGL) != gfx::kGLImplementationOSMesaName) {
+    gpu_feature_flags_ = gpu_blacklist_->DetermineGpuFeatureFlags(
+        GpuBlacklist::kOsAny, NULL, gpu_info);
+    if (gpu_feature_flags_.flags() != 0) {
+      blacklisted = true;
+      gpu_feature_flags_set_ = true;
+      gpu_info_ = gpu_info;
+      gpu_info_.SetLevel(GPUInfo::kComplete);
+      child_process_logging::SetGpuInfo(gpu_info_);
+      uint32 max_entry_id = gpu_blacklist_->max_entry_id();
+      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);
+      }
+    }
+  }
+
+  GpuHostMsg_PreliminaryGraphicsInfoCollected::WriteReplyParams(
+      reply_msg, blacklisted);
+  Send(reply_msg);
+}
+
 void GpuProcessHostUIShim::OnLogMessage(int level,
     const std::string& header,
     const std::string& message) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("level", level);
   dict->SetString("header", header);
   dict->SetString("message", message);
   log_messages_.Append(dict);
 }
 
@@ skipping 67 matching lines @@
     return true;
   static const base::StringPiece gpu_blacklist_json(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_GPU_BLACKLIST));
   gpu_blacklist_.reset(new GpuBlacklist());
   if (gpu_blacklist_->LoadGpuBlacklist(gpu_blacklist_json.as_string(), true))
     return true;
   gpu_blacklist_.reset(NULL);
   return false;
 }