Usability improvements to about:gpu status

content/browser/gpu_blacklist.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_blacklist.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
@@ skipping 675 matching lines @@
 void GpuBlacklist::GetGpuFeatureFlagEntries(
     GpuFeatureFlags::GpuFeatureType feature,
     std::vector<uint32>& entry_ids) const {
   entry_ids.clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
     if ((feature & active_entries_[i]->GetGpuFeatureFlags().flags()) != 0)
       entry_ids.push_back(active_entries_[i]->id());
   }
 }
 
+bool GpuBlacklist::IsFeatureBlacklisted(
+    GpuFeatureFlags::GpuFeatureType feature) const
+{
+  for (size_t i = 0; i < active_entries_.size(); ++i) {
+    if (active_entries_[i]->GetGpuFeatureFlags().flags() & feature)
+      return true;
+  }
+  return false;
+}
+
+namespace
+{
+
+Value* NewStatusValue(const char* name, const char* status)
+{
+  DictionaryValue* value = new DictionaryValue();
+  value->SetString("name", name);
+  value->SetString("status", status);
+  return value;
+}
+
+}

[zmo, 2011/04/15 17:06:35]

Please move this into the anonymous namespace at the top of this file.

+
 Value* GpuBlacklist::GetFeatureStatus(bool gpu_access_allowed,
                                       bool disable_accelerated_compositing,
                                       bool enable_accelerated_2D_canvas,
                                       bool disable_experimental_webgl,
                                       bool disable_multisampling) const {
   DictionaryValue* status = new DictionaryValue();
 
-  // build the feature_status field
+  // Build the feature_status field.
   {
     ListValue* feature_status_list = new ListValue();
-    // Iterate over all feature bits in kGpuFeatureAll and set feature status
-    // for each one.
-    for (size_t i = 0; i < sizeof(GpuFeatureFlags::GpuFeatureType) * 8; ++i) {
-      GpuFeatureFlags::GpuFeatureType feature =
-          static_cast<GpuFeatureFlags::GpuFeatureType>(1 << i);
-      if (!(feature & GpuFeatureFlags::kGpuFeatureAll))
-        continue;
 
-      DictionaryValue* feature_status = new DictionaryValue();
+    // 2d_canvas.
+    if (!gpu_access_allowed) {
+      if(enable_accelerated_2D_canvas)
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "unavailable_software"));
+      else
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "software"));
+    } else if (enable_accelerated_2D_canvas) {
+      if (IsFeatureBlacklisted(
+              GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas))
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "unavailable_software"));
+      else
+        feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                   "enabled"));
+    } else {
+      feature_status_list->Append(NewStatusValue("2d_canvas",
+                                                 "software"));
+    }
 
-      std::string feature_name(
-          GpuFeatureFlags::GpuFeatureTypeToString(feature));
-      feature_status->SetString("name", feature_name);
+    // 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 (IsFeatureBlacklisted(
+        GpuFeatureFlags::kGpuFeatureAcceleratedCompositing)) {
+      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"));
+    }
 
-      // figure out if the feature is on or off
-      bool blacklisted = false;
-      for (size_t i = 0; i < active_entries_.size(); ++i) {
-        if (active_entries_[i]->GetGpuFeatureFlags().flags() & feature)
-          blacklisted |= true;
-      }
+    // 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 (IsFeatureBlacklisted(
+        GpuFeatureFlags::kGpuFeatureWebgl))
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "unavailable_off"));
+    else
+      feature_status_list->Append(NewStatusValue("webgl",
+                                                 "enabled"));
 
-      // status is actually a function of blacklisting + enable/disable flags +
-      // global GPU state
-      const char* status;
-      if (!gpu_access_allowed) {
-        status = "unavailable";
-      } else {
-        switch(feature) {
-          case GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas: {
-            if (enable_accelerated_2D_canvas) {
-              if (blacklisted)
-                status = "unavailable";
-              else
-                status = "enabled";
-            } else {
-              status = "software";
-            }
-            break;
-          }
-          case GpuFeatureFlags::kGpuFeatureAcceleratedCompositing: {
-            if (disable_accelerated_compositing) {
-              status = "disabled";
-            } else {
-              if (blacklisted)
-                status = "unavailable";
-              else
-                status = "enabled";
-            }
-            break;
-          }
-          case GpuFeatureFlags::kGpuFeatureWebgl: {
-            if (disable_experimental_webgl) {
-              status = "disabled";
-            } else {
-              if (blacklisted)
-                status = "unavailable";
-              else
-                status = "enabled";
-            }
-            break;
-          }
-          case GpuFeatureFlags::kGpuFeatureMultisampling: {
-            if(disable_multisampling) {
-              status = "disabled";
-            } else {
-              if(blacklisted)
-                status = "unavailable";
-              else
-                status = "enabled";
-            }
-            break;
-          }
-          default: {
-            NOTREACHED();
-            status = "unavailable";
-            break;
-          }
-        }
-      }
-      feature_status->SetString("status", status);
+    // 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 (IsFeatureBlacklisted(
+        GpuFeatureFlags::kGpuFeatureMultisampling))
+      feature_status_list->Append(NewStatusValue("multisampling",
+                                                 "disabled_off"));
+    else
+        feature_status_list->Append(NewStatusValue("multisampling",

[zmo, 2011/04/15 17:06:35]

remove two extra white space

+                                                   "enabled"));
 
-      feature_status_list->Append(feature_status);
-    }
+
     status->Set("featureStatus", feature_status_list);
   }
 
-  // build the problems 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);
     }
@@ skipping 132 matching lines @@
     browser_version_info.reset(
       new VersionInfo(version_op, version_string, version_string2));
     if (!browser_version_info->IsValid())
       return kMalformed;
     if (browser_version_info->Contains(*browser_version_))
       return kSupported;
     return kUnsupported;
   }
   return kSupported;
 }