Blacklist bad GPU drivers: currenly we disable all gpu related features if th...

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 "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
+#include "base/string_piece.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/gpu_blacklist.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/gpu_feature_flags.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
+#include "grit/browser_resources.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_LINUX)
 #include <gdk/gdkwindow.h>
 #include <gdk/gdkx.h>
 #include "app/x11_util.h"
 #include "gfx/gtk_native_view_id_manager.h"
 #include "gfx/size.h"
@@ skipping 58 matching lines @@
 
 bool GpuProcessHost::EnsureInitialized() {
   if (!initialized_) {
     initialized_ = true;
     initialized_successfully_ = Init();
   }
   return initialized_successfully_;
 }
 
 bool GpuProcessHost::Init() {
+  if (!LoadGpuBlacklist())
+    return false;
+
   if (!CreateChannel())
     return false;
 
   if (!CanLaunchGpuProcess())
     return false;
 
   return LaunchGpuProcess();
 }
 
 // static
@@ skipping 23 matching lines @@
     RouteOnUIThread(message);
 }
 
 void GpuProcessHost::EstablishGpuChannel(int renderer_id,
                                          ResourceMessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   if (Send(new GpuMsg_EstablishChannel(renderer_id))) {
     sent_requests_.push(ChannelRequest(filter));
   } else {
-    SendEstablishChannelReply(IPC::ChannelHandle(), GPUInfo(), filter);
+    SendEstablishChannelReply(IPC::ChannelHandle(), GPUInfo(),
+                              GpuFeatureFlags(), filter);
   }
 }
 
 void GpuProcessHost::Synchronize(IPC::Message* reply,
                                  ResourceMessageFilter* filter) {
   DCHECK(CalledOnValidThread());
 
   if (Send(new GpuMsg_Synchronize())) {
     queued_synchronization_replies_.push(SynchronizationRequest(reply, filter));
   } else {
@@ skipping 38 matching lines @@
     // If the IO thread does not handle the message then automatically route it
     // to the UI thread. The UI thread will report an error if it does not
     // handle it.
     IPC_MESSAGE_UNHANDLED(RouteOnUIThread(message))
   IPC_END_MESSAGE_MAP()
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle,
     const GPUInfo& gpu_info) {
+  GpuFeatureFlags gpu_feature_flags = gpu_blacklist_->DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsAny, NULL, gpu_info);
   const ChannelRequest& request = sent_requests_.front();
-  SendEstablishChannelReply(channel_handle, gpu_info, request.filter);
+  SendEstablishChannelReply(
+      channel_handle, gpu_info, gpu_feature_flags, request.filter);
   sent_requests_.pop();
 }
 
 void GpuProcessHost::OnSynchronizeReply() {
   const SynchronizationRequest& request =
       queued_synchronization_replies_.front();
   SendSynchronizationReply(request.reply, request.filter);
   queued_synchronization_replies_.pop();
 }
 
@@ skipping 219 matching lines @@
       BrowserThread::UI, FROM_HERE,
       NewRunnableFunction(&CreateCompositorHostWindowDispatcher,
           renderer_id, render_view_id, reply_message));
 }
 
 #endif
 
 void GpuProcessHost::SendEstablishChannelReply(
     const IPC::ChannelHandle& channel,
     const GPUInfo& gpu_info,
+    const GpuFeatureFlags& gpu_feature_flags,
     ResourceMessageFilter* filter) {
   ViewMsg_GpuChannelEstablished* message =
-      new ViewMsg_GpuChannelEstablished(channel, gpu_info);
+      new ViewMsg_GpuChannelEstablished(channel, gpu_info, gpu_feature_flags);
   // If the renderer process is performing synchronous initialization,
   // it needs to handle this message before receiving the reply for
   // the synchronous ViewHostMsg_SynchronizeGpu message.
   message->set_unblock(true);
   filter->Send(message);
 }
 
 // Sends the response for synchronization request to the renderer.
 void GpuProcessHost::SendSynchronizationReply(
     IPC::Message* reply,
@@ skipping 74 matching lines @@
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
       base::environment_vector(),
 #endif
       cmd_line);
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             kLaunched, kGPUProcessLifetimeEvent_Max);
   return true;
 }
 
+bool GpuProcessHost::LoadGpuBlacklist() {
+  if (gpu_blacklist_.get() != NULL)
+    return true;
+  static const base::StringPiece gpu_blacklist_json(
+      ResourceBundle::GetSharedInstance().GetRawDataResource(
+          IDR_GPU_BLACKLIST));
+  GpuBlacklist* blacklist = new GpuBlacklist();
+  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;
+}
+