Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(5268)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/gpu_util.cc

Issue 10908110: Move gpu blacklist to content side. (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: Created 8 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/gpu_util.h ('k') | chrome/browser/gpu_util_unittest.cc » ('j') | content/browser/gpu/gpu_data_manager_impl.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/gpu_util.cc
===================================================================
--- chrome/browser/gpu_util.cc (revision 155054)
+++ chrome/browser/gpu_util.cc (working copy)
@@ -1,631 +0,0 @@
-// 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 "chrome/browser/gpu_util.h"
-
-#include <vector>
-
-#include "base/command_line.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/histogram.h"
-#include "base/string_number_conversions.h"
-#include "base/string_util.h"
-#include "base/stringprintf.h"
-#include "base/sys_info.h"
-#include "base/values.h"
-#include "base/version.h"
-#include "chrome/browser/gpu_blacklist.h"
-#include "chrome/common/chrome_version_info.h"
-#include "content/public/browser/gpu_data_manager.h"
-#include "content/public/common/compositor_util.h"
-#include "content/public/common/content_constants.h"
-#include "content/public/common/content_switches.h"
-#include "content/public/common/gpu_info.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
-
-using content::GpuDataManager;
-using content::GpuFeatureType;
-
-namespace {
-
-const char kGpuFeatureNameAccelerated2dCanvas[] = "accelerated_2d_canvas";
-const char kGpuFeatureNameAcceleratedCompositing[] = "accelerated_compositing";
-const char kGpuFeatureNameWebgl[] = "webgl";
-const char kGpuFeatureNameMultisampling[] = "multisampling";
-const char kGpuFeatureNameFlash3d[] = "flash_3d";
-const char kGpuFeatureNameFlashStage3d[] = "flash_stage3d";
-const char kGpuFeatureNameTextureSharing[] = "texture_sharing";
-const char kGpuFeatureNameAcceleratedVideoDecode[] = "accelerated_video_decode";
-const char kGpuFeatureNameAll[] = "all";
-const char kGpuFeatureNameUnknown[] = "unknown";
-
-enum GpuFeatureStatus {
- kGpuFeatureEnabled = 0,
- kGpuFeatureBlacklisted = 1,
- kGpuFeatureDisabled = 2, // disabled by user but not blacklisted
- kGpuFeatureNumStatus
-};
-
-struct GpuFeatureInfo {
- std::string name;
- uint32 blocked;
- bool disabled;
- std::string disabled_description;
- bool fallback_to_software;
-};
-
-// Determine if accelerated-2d-canvas is supported, which depends on whether
-// lose_context could happen and whether skia is the backend.
-bool SupportsAccelerated2dCanvas() {
- if (GpuDataManager::GetInstance()->GetGPUInfo().can_lose_context)
- return false;
-#if defined(USE_SKIA)
- return true;
-#else
- return false;
-#endif
-}
-
-DictionaryValue* NewDescriptionValuePair(const std::string& desc,
- const std::string& value) {
- DictionaryValue* dict = new DictionaryValue();
- dict->SetString("description", desc);
- dict->SetString("value", value);
- return dict;
-}
-
-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;
-}
-
-std::string GPUDeviceToString(const content::GPUInfo::GPUDevice& gpu) {
- std::string vendor = base::StringPrintf("0x%04x", gpu.vendor_id);
- if (!gpu.vendor_string.empty())
- vendor += " [" + gpu.vendor_string + "]";
- std::string device = base::StringPrintf("0x%04x", gpu.device_id);
- if (!gpu.device_string.empty())
- device += " [" + gpu.device_string + "]";
- return base::StringPrintf(
- "VENDOR = %s, DEVICE= %s", vendor.c_str(), device.c_str());
-}
-
-#if defined(OS_WIN)
-
-enum WinSubVersion {
- kWinOthers = 0,
- kWinXP,
- kWinVista,
- kWin7,
- kNumWinSubVersions
-};
-
-// Output DxDiagNode tree as nested array of {description,value} pairs
-ListValue* DxDiagNodeToList(const content::DxDiagNode& node) {
- ListValue* list = new ListValue();
- for (std::map<std::string, std::string>::const_iterator it =
- node.values.begin();
- it != node.values.end();
- ++it) {
- list->Append(NewDescriptionValuePair(it->first, it->second));
- }
-
- for (std::map<std::string, content::DxDiagNode>::const_iterator it =
- node.children.begin();
- it != node.children.end();
- ++it) {
- ListValue* sublist = DxDiagNodeToList(it->second);
- list->Append(NewDescriptionValuePair(it->first, sublist));
- }
- return list;
-}
-
-int GetGpuBlacklistHistogramValueWin(GpuFeatureStatus status) {
- static WinSubVersion sub_version = kNumWinSubVersions;
- if (sub_version == kNumWinSubVersions) {
- sub_version = kWinOthers;
- std::string version_str = base::SysInfo::OperatingSystemVersion();
- size_t pos = version_str.find_first_not_of("0123456789.");
- if (pos != std::string::npos)
- version_str = version_str.substr(0, pos);
- Version os_version(version_str);
- if (os_version.IsValid() && os_version.components().size() >= 2) {
- const std::vector<uint16>& version_numbers = os_version.components();
- if (version_numbers[0] == 5)
- sub_version = kWinXP;
- else if (version_numbers[0] == 6 && version_numbers[1] == 0)
- sub_version = kWinVista;
- else if (version_numbers[0] == 6 && version_numbers[1] == 1)
- sub_version = kWin7;
- }
- }
- int entry_index = static_cast<int>(sub_version) * kGpuFeatureNumStatus;
- switch (status) {
- case kGpuFeatureEnabled:
- break;
- case kGpuFeatureBlacklisted:
- entry_index++;
- break;
- case kGpuFeatureDisabled:
- entry_index += 2;
- break;
- }
- return entry_index;
-}
-#endif // OS_WIN
-
-} // namespace
-
-namespace gpu_util {
-
-void InitializeCompositingFieldTrial() {
-// Enable the field trial only on desktop OS's.
-#if !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX))
- return;
-#endif
-#if defined(OS_WIN)
- // Don't run the trial on Windows XP.
- if (base::win::GetVersion() < base::win::VERSION_VISTA)
- return;
-#endif
-
- // The performance of accelerated compositing is too low with software
- // rendering.
- if (content::GpuDataManager::GetInstance()->ShouldUseSoftwareRendering())
- return;
-
- // Don't activate the field trial if force-compositing-mode has been
- // explicitly disabled from the command line.
- if (CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kDisableForceCompositingMode))
- return;
-
- const base::FieldTrial::Probability kDivisor = 3;
- scoped_refptr<base::FieldTrial> trial(
- base::FieldTrialList::FactoryGetFieldTrial(
- content::kGpuCompositingFieldTrialName, kDivisor,
- "disable", 2012, 12, 31, NULL));
-
- // Produce the same result on every run of this client.
- trial->UseOneTimeRandomization();
-
- base::FieldTrial::Probability force_compositing_mode_probability = 0;
- base::FieldTrial::Probability threaded_compositing_probability = 0;
-
- chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
- if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
- channel == chrome::VersionInfo::CHANNEL_BETA) {
- // Stable and Beta channels: Non-threaded force-compositing-mode on by
- // default (mac and windows only).
-#if defined(OS_WIN) || defined(OS_MACOSX)
- force_compositing_mode_probability = 3;
-#endif
- } else if (channel == chrome::VersionInfo::CHANNEL_DEV ||
- channel == chrome::VersionInfo::CHANNEL_CANARY) {
- // Dev and Canary channels: force-compositing-mode and
- // threaded-compositing on with 1/3 probability each.
- force_compositing_mode_probability = 1;
-
-#if defined(OS_MACOSX) || defined(OS_LINUX)
- // Threaded compositing mode isn't feature complete on mac or linux yet:
- // http://crbug.com/133602 for mac
- // http://crbug.com/140866 for linux
- threaded_compositing_probability = 0;
-#else
- if (!CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kDisableThreadedCompositing))
- threaded_compositing_probability = 1;
-#endif
- }
-
-
- int force_compositing_group = trial->AppendGroup(
- content::kGpuCompositingFieldTrialForceCompositingEnabledName,
- force_compositing_mode_probability);
- int thread_group = trial->AppendGroup(
- content::kGpuCompositingFieldTrialThreadEnabledName,
- threaded_compositing_probability);
-
- bool force_compositing = (trial->group() == force_compositing_group);
- bool thread = (trial->group() == thread_group);
- UMA_HISTOGRAM_BOOLEAN("GPU.InForceCompositingModeFieldTrial",
- force_compositing);
- UMA_HISTOGRAM_BOOLEAN("GPU.InCompositorThreadFieldTrial", thread);
-}
-
-GpuFeatureType StringToGpuFeatureType(const std::string& feature_string) {
- if (feature_string == kGpuFeatureNameAccelerated2dCanvas)
- return content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS;
- else if (feature_string == kGpuFeatureNameAcceleratedCompositing)
- return content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING;
- else if (feature_string == kGpuFeatureNameWebgl)
- return content::GPU_FEATURE_TYPE_WEBGL;
- else if (feature_string == kGpuFeatureNameMultisampling)
- return content::GPU_FEATURE_TYPE_MULTISAMPLING;
- else if (feature_string == kGpuFeatureNameFlash3d)
- return content::GPU_FEATURE_TYPE_FLASH3D;
- else if (feature_string == kGpuFeatureNameFlashStage3d)
- return content::GPU_FEATURE_TYPE_FLASH_STAGE3D;
- else if (feature_string == kGpuFeatureNameTextureSharing)
- return content::GPU_FEATURE_TYPE_TEXTURE_SHARING;
- else if (feature_string == kGpuFeatureNameAcceleratedVideoDecode)
- return content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE;
- else if (feature_string == kGpuFeatureNameAll)
- return content::GPU_FEATURE_TYPE_ALL;
- return content::GPU_FEATURE_TYPE_UNKNOWN;
-}
-
-std::string GpuFeatureTypeToString(GpuFeatureType type) {
- std::vector<std::string> matches;
- if (type == content::GPU_FEATURE_TYPE_ALL) {
- matches.push_back(kGpuFeatureNameAll);
- } else {
- if (type & content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)
- matches.push_back(kGpuFeatureNameAccelerated2dCanvas);
- if (type & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)
- matches.push_back(kGpuFeatureNameAcceleratedCompositing);
- if (type & content::GPU_FEATURE_TYPE_WEBGL)
- matches.push_back(kGpuFeatureNameWebgl);
- if (type & content::GPU_FEATURE_TYPE_MULTISAMPLING)
- matches.push_back(kGpuFeatureNameMultisampling);
- if (type & content::GPU_FEATURE_TYPE_FLASH3D)
- matches.push_back(kGpuFeatureNameFlash3d);
- if (type & content::GPU_FEATURE_TYPE_FLASH_STAGE3D)
- matches.push_back(kGpuFeatureNameFlashStage3d);
- if (type & content::GPU_FEATURE_TYPE_TEXTURE_SHARING)
- matches.push_back(kGpuFeatureNameTextureSharing);
- if (!matches.size())
- matches.push_back(kGpuFeatureNameUnknown);
- }
- return JoinString(matches, ',');
-}
-
-Value* GetFeatureStatus() {
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
- bool gpu_access_blocked = !GpuDataManager::GetInstance()->GpuAccessAllowed();
-
- uint32 flags = GpuDataManager::GetInstance()->GetBlacklistedFeatures();
- DictionaryValue* status = new DictionaryValue();
-
- const GpuFeatureInfo kGpuFeatureInfo[] = {
- {
- "2d_canvas",
- flags & content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
- command_line.HasSwitch(switches::kDisableAccelerated2dCanvas) ||
- !SupportsAccelerated2dCanvas(),
- "Accelerated 2D canvas is unavailable: either disabled at the command"
- " line or not supported by the current system.",
- true
- },
- {
- "compositing",
- flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
- command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
- "Accelerated compositing has been disabled, either via about:flags or"
- " command line. This adversely affects performance of all hardware"
- " accelerated features.",
- true
- },
- {
- "3d_css",
- flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
- command_line.HasSwitch(switches::kDisableAcceleratedLayers),
- "Accelerated layers have been disabled at the command line.",
- false
- },
- {
- "css_animation",
- flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
- command_line.HasSwitch(switches::kDisableThreadedAnimation) ||
- command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
- "Accelerated CSS animation has been disabled at the command line.",
- true
- },
- {
- "webgl",
- flags & content::GPU_FEATURE_TYPE_WEBGL,
-#if defined(OS_ANDROID)
- !command_line.HasSwitch(switches::kEnableExperimentalWebGL),
-#else
- command_line.HasSwitch(switches::kDisableExperimentalWebGL),
-#endif
- "WebGL has been disabled, either via about:flags or command line.",
- false
- },
- {
- "multisampling",
- flags & content::GPU_FEATURE_TYPE_MULTISAMPLING,
- command_line.HasSwitch(switches::kDisableGLMultisampling),
- "Multisampling has been disabled, either via about:flags or command"
- " line.",
- false
- },
- {
- "flash_3d",
- flags & content::GPU_FEATURE_TYPE_FLASH3D,
- command_line.HasSwitch(switches::kDisableFlash3d),
- "Using 3d in flash has been disabled, either via about:flags or"
- " command line.",
- false
- },
- {
- "flash_stage3d",
- flags & content::GPU_FEATURE_TYPE_FLASH_STAGE3D,
- command_line.HasSwitch(switches::kDisableFlashStage3d),
- "Using Stage3d in Flash has been disabled, either via about:flags or"
- " command line.",
- false
- },
- {
- "texture_sharing",
- flags & content::GPU_FEATURE_TYPE_TEXTURE_SHARING,
- command_line.HasSwitch(switches::kDisableImageTransportSurface),
- "Sharing textures between processes has been disabled, either via"
- " about:flags or command line.",
- false
- },
- {
- "video_decode",
- flags & content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE,
- command_line.HasSwitch(switches::kDisableAcceleratedVideoDecode),
- "Accelerated video decode has been disabled, either via about:flags"
- " or command line.",
- true
- }
- };
- const size_t kNumFeatures = sizeof(kGpuFeatureInfo) / sizeof(GpuFeatureInfo);
-
- // Build the feature_status field.
- {
- ListValue* feature_status_list = new ListValue();
-
- for (size_t i = 0; i < kNumFeatures; ++i) {
- std::string status;
- if (kGpuFeatureInfo[i].disabled) {
- status = "disabled";
- if (kGpuFeatureInfo[i].name == "css_animation") {
- status += "_software_animated";
- } else {
- if (kGpuFeatureInfo[i].fallback_to_software)
- status += "_software";
- else
- status += "_off";
- }
- } else if (GpuDataManager::GetInstance()->ShouldUseSoftwareRendering()) {
- status = "unavailable_software";
- } else if (kGpuFeatureInfo[i].blocked ||
- gpu_access_blocked) {
- status = "unavailable";
- if (kGpuFeatureInfo[i].fallback_to_software)
- status += "_software";
- else
- status += "_off";
- } else {
- status = "enabled";
- if (kGpuFeatureInfo[i].name == "webgl" &&
- (command_line.HasSwitch(switches::kDisableAcceleratedCompositing) ||
- (flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)))
- status += "_readback";
- bool has_thread = content::IsThreadedCompositingEnabled();
- if (kGpuFeatureInfo[i].name == "compositing") {
- bool force_compositing =
- content::IsForceCompositingModeEnabled();
- if (force_compositing)
- status += "_force";
- if (has_thread)
- status += "_threaded";
- }
- if (kGpuFeatureInfo[i].name == "css_animation") {
- if (has_thread)
- status = "accelerated_threaded";
- else
- status = "accelerated";
- }
- }
- feature_status_list->Append(
- NewStatusValue(kGpuFeatureInfo[i].name.c_str(), status.c_str()));
- }
-
- status->Set("featureStatus", feature_status_list);
- }
-
- // Build the problems list.
- {
- ListValue* problem_list = new ListValue();
-
- if (gpu_access_blocked) {
- 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);
- }
-
- for (size_t i = 0; i < kNumFeatures; ++i) {
- if (kGpuFeatureInfo[i].disabled) {
- DictionaryValue* problem = new DictionaryValue();
- problem->SetString(
- "description", kGpuFeatureInfo[i].disabled_description);
- problem->Set("crBugs", new ListValue());
- problem->Set("webkitBugs", new ListValue());
- problem_list->Append(problem);
- }
- }
-
- GpuBlacklist::GetInstance()->GetBlacklistReasons(problem_list);
-
- status->Set("problems", problem_list);
- }
-
- return status;
-}
-
-DictionaryValue* GpuInfoAsDictionaryValue() {
- content::GPUInfo gpu_info = GpuDataManager::GetInstance()->GetGPUInfo();
- ListValue* basic_info = new ListValue();
- basic_info->Append(NewDescriptionValuePair(
- "Initialization time",
- base::Int64ToString(gpu_info.initialization_time.InMilliseconds())));
- basic_info->Append(NewDescriptionValuePair(
- "GPU0", GPUDeviceToString(gpu_info.gpu)));
- for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
- basic_info->Append(NewDescriptionValuePair(
- base::StringPrintf("GPU%d", static_cast<int>(i + 1)),
- GPUDeviceToString(gpu_info.secondary_gpus[i])));
- }
- basic_info->Append(NewDescriptionValuePair(
- "Optimus", Value::CreateBooleanValue(gpu_info.optimus)));
- basic_info->Append(NewDescriptionValuePair(
- "AMD switchable", Value::CreateBooleanValue(gpu_info.amd_switchable)));
- basic_info->Append(NewDescriptionValuePair("Driver vendor",
- gpu_info.driver_vendor));
- basic_info->Append(NewDescriptionValuePair("Driver version",
- gpu_info.driver_version));
- basic_info->Append(NewDescriptionValuePair("Driver date",
- gpu_info.driver_date));
- basic_info->Append(NewDescriptionValuePair("Pixel shader version",
- gpu_info.pixel_shader_version));
- basic_info->Append(NewDescriptionValuePair("Vertex shader version",
- gpu_info.vertex_shader_version));
- basic_info->Append(NewDescriptionValuePair("GL version",
- gpu_info.gl_version));
- basic_info->Append(NewDescriptionValuePair("GL_VENDOR",
- gpu_info.gl_vendor));
- basic_info->Append(NewDescriptionValuePair("GL_RENDERER",
- gpu_info.gl_renderer));
- basic_info->Append(NewDescriptionValuePair("GL_VERSION",
- gpu_info.gl_version_string));
- basic_info->Append(NewDescriptionValuePair("GL_EXTENSIONS",
- gpu_info.gl_extensions));
-
- DictionaryValue* info = new DictionaryValue();
- info->Set("basic_info", basic_info);
-
-#if defined(OS_WIN)
- ListValue* perf_info = new ListValue();
- perf_info->Append(NewDescriptionValuePair(
- "Graphics",
- base::StringPrintf("%.1f", gpu_info.performance_stats.graphics)));
- perf_info->Append(NewDescriptionValuePair(
- "Gaming",
- base::StringPrintf("%.1f", gpu_info.performance_stats.gaming)));
- perf_info->Append(NewDescriptionValuePair(
- "Overall",
- base::StringPrintf("%.1f", gpu_info.performance_stats.overall)));
- info->Set("performance_info", perf_info);
-
- Value* dx_info;
- if (gpu_info.dx_diagnostics.children.size())
- dx_info = DxDiagNodeToList(gpu_info.dx_diagnostics);
- else
- dx_info = Value::CreateNullValue();
- info->Set("diagnostics", dx_info);
-#endif
-
- return info;
-}
-
-void UpdateStats() {
- GpuBlacklist* blacklist = GpuBlacklist::GetInstance();
- uint32 max_entry_id = blacklist->max_entry_id();
- if (max_entry_id == 0) {
- // GPU Blacklist was not loaded. No need to go further.
- return;
- }
-
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
- uint32 flags = GpuDataManager::GetInstance()->GetBlacklistedFeatures();
- bool disabled = false;
- if (flags == 0) {
- UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
- 0, max_entry_id + 1);
- } else {
- std::vector<uint32> flag_entries;
- blacklist->GetGpuFeatureTypeEntries(
- content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled);
- 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);
- }
- }
-
- // This counts how many users are affected by a disabled entry - this allows
- // us to understand the impact of an entry before enable it.
- std::vector<uint32> flag_disabled_entries;
- disabled = true;
- blacklist->GetGpuFeatureTypeEntries(
- content::GPU_FEATURE_TYPE_ALL, flag_disabled_entries, disabled);
- for (size_t i = 0; i < flag_disabled_entries.size(); ++i) {
- UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerDisabledEntry",
- flag_disabled_entries[i], max_entry_id + 1);
- }
-
- const content::GpuFeatureType kGpuFeatures[] = {
- content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
- content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING,
- content::GPU_FEATURE_TYPE_WEBGL
- };
- const std::string kGpuBlacklistFeatureHistogramNames[] = {
- "GPU.BlacklistFeatureTestResults.Accelerated2dCanvas",
- "GPU.BlacklistFeatureTestResults.AcceleratedCompositing",
- "GPU.BlacklistFeatureTestResults.Webgl"
- };
- const bool kGpuFeatureUserFlags[] = {
- command_line.HasSwitch(switches::kDisableAccelerated2dCanvas),
- command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
-#if defined(OS_ANDROID)
- !command_line.HasSwitch(switches::kEnableExperimentalWebGL)
-#else
- command_line.HasSwitch(switches::kDisableExperimentalWebGL)
-#endif
- };
-#if defined(OS_WIN)
- const std::string kGpuBlacklistFeatureHistogramNamesWin[] = {
- "GPU.BlacklistFeatureTestResultsWindows.Accelerated2dCanvas",
- "GPU.BlacklistFeatureTestResultsWindows.AcceleratedCompositing",
- "GPU.BlacklistFeatureTestResultsWindows.Webgl"
- };
-#endif
- const size_t kNumFeatures =
- sizeof(kGpuFeatures) / sizeof(content::GpuFeatureType);
- for (size_t i = 0; i < kNumFeatures; ++i) {
- // We can't use UMA_HISTOGRAM_ENUMERATION here because the same name is
- // expected if the macro is used within a loop.
- GpuFeatureStatus value = kGpuFeatureEnabled;
- if (flags & kGpuFeatures[i])
- value = kGpuFeatureBlacklisted;
- else if (kGpuFeatureUserFlags[i])
- value = kGpuFeatureDisabled;
- base::Histogram* histogram_pointer = base::LinearHistogram::FactoryGet(
- kGpuBlacklistFeatureHistogramNames[i],
- 1, kGpuFeatureNumStatus, kGpuFeatureNumStatus + 1,
- base::Histogram::kUmaTargetedHistogramFlag);
- histogram_pointer->Add(value);
-#if defined(OS_WIN)
- histogram_pointer = base::LinearHistogram::FactoryGet(
- kGpuBlacklistFeatureHistogramNamesWin[i],
- 1, kNumWinSubVersions * kGpuFeatureNumStatus,
- kNumWinSubVersions * kGpuFeatureNumStatus + 1,
- base::Histogram::kUmaTargetedHistogramFlag);
- histogram_pointer->Add(GetGpuBlacklistHistogramValueWin(value));
-#endif
- }
-}
-
-} // namespace gpu_util;
« no previous file with comments | « chrome/browser/gpu_util.h ('k') | chrome/browser/gpu_util_unittest.cc » ('j') | content/browser/gpu/gpu_data_manager_impl.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698