Implement --use-gl=any

content/browser/gpu/gpu_data_manager.cc

 // Copyright (c) 2011 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.h"
 
 #if defined(OS_MACOSX)
 #include <CoreGraphics/CGDisplayConfiguration.h>
 #endif
 
@@ skipping 42 matching lines @@
 }
 
 DictionaryValue* NewDescriptionValuePair(const std::string& desc,
     Value* value) {
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString("description", desc);
   dict->Set("value", value);
   return dict;
 }
 
+Value* NewStatusValue(const char* name, const char* status) {
+  DictionaryValue* value = new DictionaryValue();
+  value->SetString("name", name);
+  value->SetString("status", status);
+  return value;
+}
+
+bool UseGLIsOSMesaOrAny() {
+  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
+  std::string gl = browser_command_line.GetSwitchValueASCII(switches::kUseGL);
+  return (gl == gfx::kGLImplementationAnyName ||
+          gl == gfx::kGLImplementationOSMesaName);
+}
+
 #if defined(OS_WIN)
 enum WinSubVersion {
   kWinOthers = 0,
   kWinXP,
   kWinVista,
   kWin7,
   kNumWinSubVersions
 };
 
 // Output DxDiagNode tree as nested array of {description,value} pairs
@@ skipping 101 matching lines @@
 
   UpdateGpuFeatureFlags();
 }
 
 const GPUInfo& GpuDataManager::gpu_info() const {
   base::AutoLock auto_lock(gpu_info_lock_);
   return gpu_info_;
 }
 
 Value* GpuDataManager::GetFeatureStatus() {
-  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
-  if (gpu_blacklist_.get())
-    return gpu_blacklist_->GetFeatureStatus(GpuAccessAllowed(),
-        browser_command_line.HasSwitch(
-            switches::kDisableAcceleratedCompositing),
-        browser_command_line.HasSwitch(
-            switches::kDisableAccelerated2dCanvas),
-        browser_command_line.HasSwitch(switches::kDisableExperimentalWebGL),
-        browser_command_line.HasSwitch(switches::kDisableGLMultisampling));
-  return NULL;
+  const CommandLine& browser_command_line =
+      *CommandLine::ForCurrentProcess();
+  bool gpu_access_allowed = GpuAccessAllowed();
+  bool disable_accelerated_compositing = browser_command_line.HasSwitch(
+      switches::kDisableAcceleratedCompositing);
+  bool disable_accelerated_2D_canvas = browser_command_line.HasSwitch(
+      switches::kDisableAccelerated2dCanvas);
+  bool disable_experimental_webgl = browser_command_line.HasSwitch(
+      switches::kDisableExperimentalWebGL);
+  bool disable_multisampling = browser_command_line.HasSwitch(
+      switches::kDisableGLMultisampling);
+
+  uint32 flags = GetGpuFeatureFlags().flags();
+  DictionaryValue* status = new DictionaryValue();
+
+  // Build the feature_status field.
+  {
+    ListValue* feature_status_list = new ListValue();
+
+    // 2d_canvas.
+    if (!gpu_access_allowed) {
+      if (disable_accelerated_2D_canvas)
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "software"));
+      else
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "unavailable_software"));
+    } else if (!disable_accelerated_2D_canvas) {
+      if ((flags & GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas) != 0)
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "unavailable_software"));
+      else if (disable_accelerated_compositing)
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "disabled_software"));
+      else
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "enabled"));
+    } else {
+      feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                 "software"));
+    }
+
+    // 3d css and compositing.
+    if (!gpu_access_allowed) {
+      feature_status_list->Append(NewStatusValue("3d_css",
+                                                 "unavailable_off"));
+      feature_status_list->Append(NewStatusValue("compositing",
+                                                 "unavailable_software"));
+    } else if (disable_accelerated_compositing) {
+      feature_status_list->Append(NewStatusValue("3d_css",
+                                                 "unavailable_off"));
+      feature_status_list->Append(NewStatusValue("compositing",
+                                                 "disabled_software"));
+    } else if ((flags &
+        GpuFeatureFlags::kGpuFeatureAcceleratedCompositing) != 0) {
+      feature_status_list->Append(NewStatusValue("3d_css",
+                                                 "unavailable_off"));
+      feature_status_list->Append(NewStatusValue("compositing",
+                                                 "disabled_software"));
+    } else {
+      feature_status_list->Append(NewStatusValue("3d_css",
+                                                 "enabled"));
+      feature_status_list->Append(NewStatusValue("compositing",
+                                                 "enabled"));
+    }
+
+    // webgl
+    if (!gpu_access_allowed)
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "unavailable_off"));
+    else if (disable_experimental_webgl)
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "disabled_off"));
+    else if ((flags & GpuFeatureFlags::kGpuFeatureWebgl) != 0)
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "unavailable_off"));
+    else if (disable_accelerated_compositing)
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "enabled_readback"));
+    else
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "enabled"));
+
+    // multisampling
+    if (!gpu_access_allowed)
+      feature_status_list->Append(NewStatusValue("multisampling",
+                                                 "unavailable_off"));
+    else if (disable_multisampling)
+      feature_status_list->Append(NewStatusValue("multisampling",
+                                                 "disabled_off"));
+    else if ((flags & GpuFeatureFlags::kGpuFeatureMultisampling) != 0)
+      feature_status_list->Append(NewStatusValue("multisampling",
+                                                 "disabled_off"));
+    else
+      feature_status_list->Append(NewStatusValue("multisampling",
+                                                 "enabled"));
+
+    status->Set("featureStatus", feature_status_list);
+  }
+
+  // Build the problems list.
+  {
+    ListValue* problem_list = new ListValue();
+    if (!gpu_access_allowed) {
+      DictionaryValue* problem = new DictionaryValue();
+      problem->SetString("description",
+          "GPU process was unable to boot. Access to GPU disallowed.");
+      problem->Set("crBugs", new ListValue());
+      problem->Set("webkitBugs", new ListValue());
+      problem_list->Append(problem);
+    }
+    if (disable_accelerated_2D_canvas) {
+      DictionaryValue* problem = new DictionaryValue();
+      problem->SetString("description",
+          "Accelerated 2D canvas has been disabled at the command line");
+      problem->Set("crBugs", new ListValue());
+      problem->Set("webkitBugs", new ListValue());
+      problem_list->Append(problem);
+    }
+    if (disable_accelerated_compositing) {
+      DictionaryValue* problem = new DictionaryValue();
+      problem->SetString("description",
+          "Accelerated compositing has been disabled, either via about:flags "
+          "or command line. This adversely affects performance of all hardware "
+          " accelerated features.");
+      problem->Set("crBugs", new ListValue());
+      problem->Set("webkitBugs", new ListValue());
+      problem_list->Append(problem);
+    }
+    if (disable_experimental_webgl) {
+      DictionaryValue* problem = new DictionaryValue();
+      problem->SetString("description",
+          "WebGL has been disabled, either via about:flags "
+          "or command line");
+      problem->Set("crBugs", new ListValue());
+      problem->Set("webkitBugs", new ListValue());
+      problem_list->Append(problem);
+    }
+    if (disable_multisampling) {
+      DictionaryValue* problem = new DictionaryValue();
+      problem->SetString("description",
+          "Multisampling has been disabled, either via about:flags "
+          "or command line");
+      problem->Set("crBugs", new ListValue());
+      problem->Set("webkitBugs", new ListValue());
+      problem_list->Append(problem);
+    }
+    GpuBlacklist* blacklist = GetGpuBlacklist();
+    if (blacklist && (!UseGLIsOSMesaOrAny()))
+      blacklist->GetBlacklistReasons(problem_list);
+    status->Set("problems", problem_list);
+  }
+  return status;
 }
 
 std::string GpuDataManager::GetBlacklistVersion() const {
   if (gpu_blacklist_.get() != NULL) {
     uint16 version_major, version_minor;
     if (gpu_blacklist_->GetVersion(&version_major,
                                    &version_minor)) {
       std::string version_string =
           base::UintToString(static_cast<unsigned>(version_major)) +
           "." +
           base::UintToString(static_cast<unsigned>(version_minor));
       return version_string;
     }
   }
   return "";
 }
 
 void GpuDataManager::AddLogMessage(Value* msg) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   log_messages_.Append(msg);
 }
 
 const ListValue& GpuDataManager::log_messages() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return log_messages_;
 }
 
 GpuFeatureFlags GpuDataManager::GetGpuFeatureFlags() {
+  if (UseGLIsOSMesaOrAny())
+    return GpuFeatureFlags();
   return gpu_feature_flags_;
 }
 
 bool GpuDataManager::GpuAccessAllowed() {
+  if (UseGLIsOSMesaOrAny())
+    return true;
+
   // We only need to block GPU process if more features are disallowed other
   // than those in the preliminary gpu feature flags because the latter work
   // through renderer commandline switches.
   uint32 mask = (~(preliminary_gpu_feature_flags_.flags()));
   return (gpu_feature_flags_.flags() & mask) == 0;
 }
 
 void GpuDataManager::AddGpuInfoUpdateCallback(Callback0::Type* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   gpu_info_update_callbacks_.insert(callback);
@@ skipping 26 matching lines @@
       !command_line->HasSwitch(switches::kDisableGLMultisampling))
     command_line->AppendSwitch(switches::kDisableGLMultisampling);
   if ((flags & GpuFeatureFlags::kGpuFeatureAcceleratedCompositing) &&
       !command_line->HasSwitch(switches::kDisableAcceleratedCompositing))
     command_line->AppendSwitch(switches::kDisableAcceleratedCompositing);
   if ((flags & GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas) &&
       !command_line->HasSwitch(switches::kDisableAccelerated2dCanvas))
     command_line->AppendSwitch(switches::kDisableAccelerated2dCanvas);
 }
 
+void GpuDataManager::AppendGpuCommandLine(
+    CommandLine* command_line) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(command_line);
+
+  uint32 flags = gpu_feature_flags_.flags();
+  if ((flags & GpuFeatureFlags::kGpuFeatureMultisampling) &&
+      !command_line->HasSwitch(switches::kDisableGLMultisampling))
+    command_line->AppendSwitch(switches::kDisableGLMultisampling);
+
+  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
+  if ((flags & (GpuFeatureFlags::kGpuFeatureWebgl |
+                GpuFeatureFlags::kGpuFeatureAcceleratedCompositing |
+                GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas)) &&
+      (browser_command_line.GetSwitchValueASCII(
+          switches::kUseGL) == gfx::kGLImplementationAnyName)) {
+    command_line->AppendSwitchASCII(
+        switches::kUseGL, gfx::kGLImplementationOSMesaName);
+  } else if (browser_command_line.HasSwitch(switches::kUseGL)) {
+    command_line->AppendSwitchASCII(switches::kUseGL,
+        browser_command_line.GetSwitchValueASCII(switches::kUseGL));
+  }
+}
+
 void GpuDataManager::SetBuiltInGpuBlacklist(GpuBlacklist* built_in_list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(built_in_list);
   uint16 version_major, version_minor;
   bool succeed = built_in_list->GetVersion(
       &version_major, &version_minor);
   DCHECK(succeed);
   gpu_blacklist_.reset(built_in_list);
   UpdateGpuFeatureFlags();
   preliminary_gpu_feature_flags_ = gpu_feature_flags_;
@@ skipping 174 matching lines @@
     histogram_pointer->Add(
         GetGpuBlacklistHistogramValueWin(
             (flags & kGpuFeatures[i]) ? true : false));
 #endif
   }
 }
 
 GpuBlacklist* GpuDataManager::GetGpuBlacklist() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
-  if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) ||
-      browser_command_line.GetSwitchValueASCII(
-          switches::kUseGL) == gfx::kGLImplementationOSMesaName)
+  if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist))
     return NULL;
   // No need to return an empty blacklist.
   if (gpu_blacklist_.get() != NULL && gpu_blacklist_->max_entry_id() == 0)
     return NULL;
   return gpu_blacklist_.get();
 }