Windows: Automatically disable GPU sandbox when DisplayLink is installed.

content/browser/gpu/gpu_data_manager_impl.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 "content/browser/gpu/gpu_data_manager_impl.h"
 
+#include <set>
+
 #if defined(OS_MACOSX)
 #include <ApplicationServices/ApplicationServices.h>
 #endif  // OS_MACOSX
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
+#include "base/string16.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_util.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_info_collector.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "grit/content_resources.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "webkit/plugins/plugin_switches.h"
 
 #if defined(OS_WIN)
+#include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #endif
 
 namespace content {
 namespace {
 
 // Strip out the non-digital info; if after that, we get an empty string,
 // return "0".
 std::string ProcessVersionString(const std::string& raw_string) {
   const std::string valid_set = "0123456789.";
@@ skipping 27 matching lines @@
 const int kNumResetsWithinDuration = 1;
 
 // Enums for UMA histograms.
 enum BlockStatusHistogram {
   BLOCK_STATUS_NOT_BLOCKED,
   BLOCK_STATUS_SPECIFIC_DOMAIN_BLOCKED,
   BLOCK_STATUS_ALL_DOMAINS_BLOCKED,
   BLOCK_STATUS_MAX
 };
 
+#if defined(OS_WIN)
+bool GetInstalledProgramDisplayNames(std::set<string16>* display_names) {
+  base::win::RegKey key;
+
+  if (FAILED(key.Open(
+      HKEY_LOCAL_MACHINE, L"SOFTWARE", KEY_READ | KEY_WOW64_64KEY))) {
+    return false;
+  }
+
+  if (FAILED(key.OpenKey(L"Microsoft", KEY_READ | KEY_WOW64_64KEY)))
+    return false;
+
+  if (FAILED(key.OpenKey(L"Windows", KEY_READ | KEY_WOW64_64KEY)))
+    return false;
+
+  if (FAILED(key.OpenKey(L"CurrentVersion", KEY_READ | KEY_WOW64_64KEY)))
+    return false;
+
+  if (FAILED(key.OpenKey(L"Uninstall", KEY_READ | KEY_WOW64_64KEY)))
+    return false;
+
+  for (base::win::RegistryKeyIterator key_it(key.Handle(), NULL);
+       key_it.Valid();
+       ++key_it) {
+    base::win::RegKey sub_key;
+    if (FAILED(sub_key.Open(
+        key.Handle(), key_it.Name(), KEY_READ | KEY_WOW64_64KEY))) {
+      continue;
+    }
+
+    string16 display_name;
+    if (FAILED(sub_key.ReadValue(L"DisplayName", &display_name)))
+      continue;
+
+    display_names->insert(display_name);
+  }
+
+  return true;
+}
+#endif
 }  // namespace anonymous
 
 // static
 GpuDataManager* GpuDataManager::GetInstance() {
   return GpuDataManagerImpl::GetInstance();
 }
 
 // static
 GpuDataManagerImpl* GpuDataManagerImpl::GetInstance() {
   return Singleton<GpuDataManagerImpl>::get();
@@ skipping 333 matching lines @@
         break;
     }
   } else {
     command_line->AppendSwitchASCII(switches::kSupportsDualGpus, "false");
   }
 
   if (!swiftshader_path.empty())
     command_line->AppendSwitchPath(switches::kSwiftShaderPath,
                                    swiftshader_path);
 
+#if defined(OS_WIN)
+  // DisplayLink drivers cause a hang when running in the GPU process sandbox.
+  std::set<string16> installed_display_names;
+  if (GetInstalledProgramDisplayNames(&installed_display_names)) {
+    if (installed_display_names.find(L"DisplayLink Core Software") !=
+        installed_display_names.end()) {
+      command_line->AppendSwitch(switches::kReduceGpuSandbox);
+    }
+  }
+#endif
+
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     if (gpu_info_.optimus)
       command_line->AppendSwitch(switches::kReduceGpuSandbox);
     if (gpu_info_.amd_switchable) {
       // The image transport surface currently doesn't work with AMD Dynamic
       // Switchable graphics.
       command_line->AppendSwitch(switches::kReduceGpuSandbox);
       command_line->AppendSwitch(switches::kDisableImageTransportSurface);
     }
@@ skipping 348 matching lines @@
 
 void GpuDataManagerImpl::Notify3DAPIBlocked(const GURL& url,
                                             int render_process_id,
                                             int render_view_id,
                                             ThreeDAPIType requester) {
   observer_list_->Notify(&GpuDataManagerObserver::DidBlock3DAPIs,
                          url, render_process_id, render_view_id, requester);
 }
 
 }  // namespace content