diff --git a/content/browser/devtools/protocol/system_info_handler.cc b/content/browser/devtools/protocol/system_info_handler.cc index 325c5afcc5f89..0a7de38f399e6 100644 --- a/content/browser/devtools/protocol/system_info_handler.cc +++ b/content/browser/devtools/protocol/system_info_handler.cc @@ -230,7 +230,8 @@ void SendGetInfoResponse(std::unique_ptr callback) { enumerator.EndAuxAttributes(); std::unique_ptr base_feature_status = - GetFeatureStatus(); + base::DictionaryValue::From( + std::make_unique(GetFeatureStatus())); std::unique_ptr feature_status = protocol::DictionaryValue::cast( protocol::toProtocolValue(base_feature_status.get(), 1000)); diff --git a/content/browser/gpu/compositor_util.cc b/content/browser/gpu/compositor_util.cc index 2f29c71b1826d..d3604f9188367 100644 --- a/content/browser/gpu/compositor_util.cc +++ b/content/browser/gpu/compositor_util.cc @@ -19,6 +19,7 @@ #include "base/strings/string_number_conversions.h" #include "base/strings/string_split.h" #include "base/system/sys_info.h" +#include "base/values.h" #include "build/build_config.h" #include "build/chromeos_buildflags.h" #include "cc/base/switches.h" @@ -195,8 +196,7 @@ const GpuFeatureData GetGpuFeatureData( return kGpuFeatureData[index]; } -std::unique_ptr GetFeatureStatusImpl( - GpuFeatureInfoType type) { +base::Value GetFeatureStatusImpl(GpuFeatureInfoType type) { GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance(); std::string gpu_access_blocked_reason; bool gpu_access_blocked; @@ -214,7 +214,7 @@ std::unique_ptr GetFeatureStatusImpl( manager->IsGpuCompositingDisabledForHardwareGpu(); } - auto feature_status_dict = std::make_unique(); + auto feature_status_dict = base::Value(base::Value::Type::DICTIONARY); bool eof = false; for (size_t i = 0; !eof; ++i) { @@ -262,12 +262,12 @@ std::unique_ptr GetFeatureStatusImpl( status += "_on"; } } - feature_status_dict->SetString(gpu_feature_data.name, status); + feature_status_dict.SetStringKey(gpu_feature_data.name, status); } return feature_status_dict; } -std::unique_ptr GetProblemsImpl(GpuFeatureInfoType type) { +base::Value GetProblemsImpl(GpuFeatureInfoType type) { GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance(); std::string gpu_access_blocked_reason; bool gpu_access_blocked; @@ -285,29 +285,29 @@ std::unique_ptr GetProblemsImpl(GpuFeatureInfoType type) { manager->IsGpuCompositingDisabledForHardwareGpu(); } - auto problem_list = std::make_unique(); + auto problem_list = base::Value(base::Value::Type::LIST); if (!gpu_feature_info.applied_gpu_blocklist_entries.empty()) { std::unique_ptr blocklist(gpu::GpuBlocklist::Create()); - blocklist->GetReasons(problem_list.get(), "disabledFeatures", + blocklist->GetReasons(problem_list, "disabledFeatures", gpu_feature_info.applied_gpu_blocklist_entries); } if (!gpu_feature_info.applied_gpu_driver_bug_list_entries.empty()) { std::unique_ptr bug_list( gpu::GpuDriverBugList::Create()); - bug_list->GetReasons(problem_list.get(), "workarounds", + bug_list->GetReasons(problem_list, "workarounds", gpu_feature_info.applied_gpu_driver_bug_list_entries); } if (gpu_access_blocked) { - auto problem = std::make_unique(); - problem->SetString("description", "GPU process was unable to boot: " + - gpu_access_blocked_reason); - problem->Set("crBugs", std::make_unique()); - auto disabled_features = std::make_unique(); - disabled_features->AppendString("all"); - problem->Set("affectedGpuSettings", std::move(disabled_features)); - problem->SetString("tag", "disabledFeatures"); - problem_list->Insert(0, std::move(problem)); + auto problem = base::Value(base::Value::Type::DICTIONARY); + problem.SetStringKey("description", "GPU process was unable to boot: " + + gpu_access_blocked_reason); + problem.SetKey("crBugs", base::Value(base::Value::Type::LIST)); + auto disabled_features = base::Value(base::Value::Type::LIST); + disabled_features.Append("all"); + problem.SetKey("affectedGpuSettings", std::move(disabled_features)); + problem.SetStringKey("tag", "disabledFeatures"); + problem_list.Insert(problem_list.GetList().begin(), std::move(problem)); } bool eof = false; @@ -316,15 +316,15 @@ std::unique_ptr GetProblemsImpl(GpuFeatureInfoType type) { gpu_feature_info, i, is_gpu_compositing_disabled, &eof); if (gpu_feature_data.disabled && gpu_feature_data.disabled_info.is_problem) { - auto problem = std::make_unique(); - problem->SetString("description", - gpu_feature_data.disabled_info.description); - problem->Set("crBugs", std::make_unique()); - auto disabled_features = std::make_unique(); - disabled_features->AppendString(gpu_feature_data.name); - problem->Set("affectedGpuSettings", std::move(disabled_features)); - problem->SetString("tag", "disabledFeatures"); - problem_list->Append(std::move(problem)); + auto problem = base::Value(base::Value::Type::DICTIONARY); + problem.SetStringKey("description", + gpu_feature_data.disabled_info.description); + problem.SetKey("crBugs", base::Value(base::Value::Type::LIST)); + auto disabled_features = base::Value(base::Value::Type::LIST); + disabled_features.Append(gpu_feature_data.name); + problem.SetKey("affectedGpuSettings", std::move(disabled_features)); + problem.SetStringKey("tag", "disabledFeatures"); + problem_list.Insert(problem_list.GetList().begin(), std::move(problem)); } } return problem_list; @@ -473,11 +473,11 @@ bool IsMainFrameBeforeActivationEnabled() { return true; } -std::unique_ptr GetFeatureStatus() { +base::Value GetFeatureStatus() { return GetFeatureStatusImpl(GpuFeatureInfoType::kCurrent); } -std::unique_ptr GetProblems() { +base::Value GetProblems() { return GetProblemsImpl(GpuFeatureInfoType::kCurrent); } @@ -485,11 +485,11 @@ std::vector GetDriverBugWorkarounds() { return GetDriverBugWorkaroundsImpl(GpuFeatureInfoType::kCurrent); } -std::unique_ptr GetFeatureStatusForHardwareGpu() { +base::Value GetFeatureStatusForHardwareGpu() { return GetFeatureStatusImpl(GpuFeatureInfoType::kForHardwareGpu); } -std::unique_ptr GetProblemsForHardwareGpu() { +base::Value GetProblemsForHardwareGpu() { return GetProblemsImpl(GpuFeatureInfoType::kForHardwareGpu); } diff --git a/content/browser/gpu/compositor_util.h b/content/browser/gpu/compositor_util.h index c7155e6dec9ec..2d7ece9f191f7 100644 --- a/content/browser/gpu/compositor_util.h +++ b/content/browser/gpu/compositor_util.h @@ -37,13 +37,12 @@ CONTENT_EXPORT int NumberOfRendererRasterThreads(); // Returns true if main thread can be pipelined with activation. CONTENT_EXPORT bool IsMainFrameBeforeActivationEnabled(); -CONTENT_EXPORT std::unique_ptr GetFeatureStatus(); -CONTENT_EXPORT std::unique_ptr GetProblems(); +CONTENT_EXPORT base::Value GetFeatureStatus(); +CONTENT_EXPORT base::Value GetProblems(); CONTENT_EXPORT std::vector GetDriverBugWorkarounds(); -CONTENT_EXPORT std::unique_ptr -GetFeatureStatusForHardwareGpu(); -CONTENT_EXPORT std::unique_ptr GetProblemsForHardwareGpu(); +CONTENT_EXPORT base::Value GetFeatureStatusForHardwareGpu(); +CONTENT_EXPORT base::Value GetProblemsForHardwareGpu(); CONTENT_EXPORT std::vector GetDriverBugWorkaroundsForHardwareGpu(); } // namespace content diff --git a/content/browser/gpu/gpu_internals_ui.cc b/content/browser/gpu/gpu_internals_ui.cc index 23dfde867df5e..f4169cdea9a2e 100644 --- a/content/browser/gpu/gpu_internals_ui.cc +++ b/content/browser/gpu/gpu_internals_ui.cc @@ -107,41 +107,38 @@ WebUIDataSource* CreateGpuHTMLSource() { } // Must be in sync with the copy in //ui/base/x/x11_util.cc. -std::unique_ptr NewDescriptionValuePair( - base::StringPiece desc, - base::StringPiece value) { - std::unique_ptr dict(new base::DictionaryValue()); - dict->SetString("description", desc); - dict->SetString("value", value); +base::Value NewDescriptionValuePair(base::StringPiece desc, + base::StringPiece value) { + base::Value dict(base::Value::Type::DICTIONARY); + dict.SetStringKey("description", desc); + dict.SetStringKey("value", value); return dict; } -std::unique_ptr NewDescriptionValuePair( - base::StringPiece desc, - std::unique_ptr value) { - std::unique_ptr dict(new base::DictionaryValue()); - dict->SetString("description", desc); - dict->Set("value", std::move(value)); +base::Value NewDescriptionValuePair(base::StringPiece desc, base::Value value) { + base::Value dict(base::Value::Type::DICTIONARY); + dict.SetStringKey("description", desc); + dict.SetKey("value", std::move(value)); return dict; } #if defined(OS_WIN) // Output DxDiagNode tree as nested array of {description,value} pairs -std::unique_ptr DxDiagNodeToList(const gpu::DxDiagNode& node) { - auto list = std::make_unique(); +base::Value DxDiagNodeToList(const gpu::DxDiagNode& node) { + base::Value list(base::Value::Type::LIST); for (std::map::const_iterator it = node.values.begin(); it != node.values.end(); ++it) { - list->Append(NewDescriptionValuePair(it->first, it->second)); + list.Append(NewDescriptionValuePair(it->first, it->second)); } for (std::map::const_iterator it = node.children.begin(); it != node.children.end(); ++it) { - std::unique_ptr sublist = DxDiagNodeToList(it->second); - list->Append(NewDescriptionValuePair(it->first, std::move(sublist))); + base::Value sublist(DxDiagNodeToList(it->second)); + list.Append(NewDescriptionValuePair(it->first, std::move(sublist))); } return list; } @@ -173,58 +170,54 @@ std::string GPUDeviceToString(const gpu::GPUInfo::GPUDevice& gpu) { return rt; } -std::unique_ptr BasicGpuInfoAsListValue( - const gpu::GPUInfo& gpu_info, - const gpu::GpuFeatureInfo& gpu_feature_info, - const gfx::GpuExtraInfo& gpu_extra_info) { +base::Value BasicGpuInfoAsListValue(const gpu::GPUInfo& gpu_info, + const gpu::GpuFeatureInfo& gpu_feature_info, + const gfx::GpuExtraInfo& gpu_extra_info) { const gpu::GPUInfo::GPUDevice& active_gpu = gpu_info.active_gpu(); - auto basic_info = std::make_unique(); - basic_info->Append(NewDescriptionValuePair( + auto basic_info = base::Value(base::Value::Type::LIST); + basic_info.Append(NewDescriptionValuePair( "Initialization time", base::NumberToString(gpu_info.initialization_time.InMilliseconds()))); - basic_info->Append(NewDescriptionValuePair( - "In-process GPU", - std::make_unique(gpu_info.in_process_gpu))); - basic_info->Append(NewDescriptionValuePair( - "Passthrough Command Decoder", - std::make_unique(gpu_info.passthrough_cmd_decoder))); - basic_info->Append(NewDescriptionValuePair( - "Sandboxed", std::make_unique(gpu_info.sandboxed))); - basic_info->Append( + basic_info.Append(NewDescriptionValuePair( + "In-process GPU", base::Value(gpu_info.in_process_gpu))); + basic_info.Append( + NewDescriptionValuePair("Passthrough Command Decoder", + base::Value(gpu_info.passthrough_cmd_decoder))); + basic_info.Append( + NewDescriptionValuePair("Sandboxed", base::Value(gpu_info.sandboxed))); + 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( + basic_info.Append(NewDescriptionValuePair( base::StringPrintf("GPU%d", static_cast(i + 1)), GPUDeviceToString(gpu_info.secondary_gpus[i]))); } - basic_info->Append(NewDescriptionValuePair( - "Optimus", std::make_unique(gpu_info.optimus))); - basic_info->Append(NewDescriptionValuePair( - "AMD switchable", - std::make_unique(gpu_info.amd_switchable))); + basic_info.Append( + NewDescriptionValuePair("Optimus", base::Value(gpu_info.optimus))); + basic_info.Append(NewDescriptionValuePair( + "AMD switchable", base::Value(gpu_info.amd_switchable))); #if defined(OS_WIN) std::string compositor = ui::win::IsAeroGlassEnabled() ? "Aero Glass" : "none"; - basic_info->Append( - NewDescriptionValuePair("Desktop compositing", compositor)); + basic_info.Append(NewDescriptionValuePair("Desktop compositing", compositor)); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "Direct composition", - std::make_unique(gpu_info.overlay_info.direct_composition))); - basic_info->Append(NewDescriptionValuePair( + base::Value(gpu_info.overlay_info.direct_composition))); + basic_info.Append(NewDescriptionValuePair( "Supports overlays", - std::make_unique(gpu_info.overlay_info.supports_overlays))); - basic_info->Append(NewDescriptionValuePair( + base::Value(gpu_info.overlay_info.supports_overlays))); + basic_info.Append(NewDescriptionValuePair( "YUY2 overlay support", gpu::OverlaySupportToString(gpu_info.overlay_info.yuy2_overlay_support))); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "NV12 overlay support", gpu::OverlaySupportToString(gpu_info.overlay_info.nv12_overlay_support))); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "BGRA8 overlay support", gpu::OverlaySupportToString( gpu_info.overlay_info.bgra8_overlay_support))); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "RGB10A2 overlay support", gpu::OverlaySupportToString( gpu_info.overlay_info.rgb10a2_overlay_support))); @@ -240,53 +233,51 @@ std::unique_ptr BasicGpuInfoAsListValue( std::string size_string = base::StringPrintf("%.1f\"", rounded_size_inches); std::string description_string = base::StringPrintf( "Diagonal Monitor Size of %s", display_size.display_name.c_str()); - basic_info->Append( - NewDescriptionValuePair(description_string, size_string)); + basic_info.Append(NewDescriptionValuePair(description_string, size_string)); } - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "Driver D3D12 feature level", gpu::D3DFeatureLevelToString(gpu_info.d3d12_feature_level))); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "Driver Vulkan API version", gpu::VulkanVersionToString(gpu_info.vulkan_version))); #endif - basic_info->Append( + basic_info.Append( NewDescriptionValuePair("Driver vendor", active_gpu.driver_vendor)); - basic_info->Append( + basic_info.Append( NewDescriptionValuePair("Driver version", active_gpu.driver_version)); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "GPU CUDA compute capability major version", - std::make_unique(active_gpu.cuda_compute_capability_major))); - 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( + base::Value(active_gpu.cuda_compute_capability_major))); + 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("Max. MSAA samples", gpu_info.max_msaa_samples)); - basic_info->Append(NewDescriptionValuePair("Machine model name", - gpu_info.machine_model_name)); - basic_info->Append(NewDescriptionValuePair("Machine model version", - gpu_info.machine_model_version)); - basic_info->Append(NewDescriptionValuePair("GL_VENDOR", gpu_info.gl_vendor)); - basic_info->Append( + basic_info.Append(NewDescriptionValuePair("Machine model name", + gpu_info.machine_model_name)); + basic_info.Append(NewDescriptionValuePair("Machine model version", + gpu_info.machine_model_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)); - basic_info->Append( + basic_info.Append(NewDescriptionValuePair("GL_VERSION", gpu_info.gl_version)); + basic_info.Append( NewDescriptionValuePair("GL_EXTENSIONS", gpu_info.gl_extensions)); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "Disabled Extensions", gpu_feature_info.disabled_extensions)); - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "Disabled WebGL Extensions", gpu_feature_info.disabled_webgl_extensions)); - basic_info->Append(NewDescriptionValuePair("Window system binding vendor", - gpu_info.gl_ws_vendor)); - basic_info->Append(NewDescriptionValuePair("Window system binding version", - gpu_info.gl_ws_version)); - basic_info->Append(NewDescriptionValuePair("Window system binding extensions", - gpu_info.gl_ws_extensions)); + basic_info.Append(NewDescriptionValuePair("Window system binding vendor", + gpu_info.gl_ws_vendor)); + basic_info.Append(NewDescriptionValuePair("Window system binding version", + gpu_info.gl_ws_version)); + basic_info.Append(NewDescriptionValuePair("Window system binding extensions", + gpu_info.gl_ws_extensions)); { base::Value gpu_extra_info_as_list_value = @@ -301,7 +292,7 @@ std::unique_ptr BasicGpuInfoAsListValue( LOG(WARNING) << "Unexpected item format: should have a string " "description and a value."; } - basic_info->Append(std::move(pair)); + basic_info.Append(std::move(pair)); } } } @@ -319,17 +310,17 @@ std::unique_ptr BasicGpuInfoAsListValue( } else { direct_rendering_version = "unknown"; } - basic_info->Append(NewDescriptionValuePair("Direct rendering version", - direct_rendering_version)); + basic_info.Append(NewDescriptionValuePair("Direct rendering version", + direct_rendering_version)); std::string reset_strategy = base::StringPrintf("0x%04x", gpu_info.gl_reset_notification_strategy); - basic_info->Append( + basic_info.Append( NewDescriptionValuePair("Reset notification strategy", reset_strategy)); - basic_info->Append(NewDescriptionValuePair( - "GPU process crash count", - std::make_unique(GpuProcessHost::GetGpuCrashCount()))); + basic_info.Append( + NewDescriptionValuePair("GPU process crash count", + base::Value(GpuProcessHost::GetGpuCrashCount()))); std::string buffer_formats; for (int i = 0; i <= static_cast(gfx::BufferFormat::LAST); ++i) { @@ -342,15 +333,15 @@ std::unique_ptr BasicGpuInfoAsListValue( buffer_format); buffer_formats += supported ? ": supported" : ": not supported"; } - basic_info->Append(NewDescriptionValuePair( + basic_info.Append(NewDescriptionValuePair( "gfx::BufferFormats supported for allocation and texturing", buffer_formats)); return basic_info; } -std::unique_ptr GpuInfoAsDictionaryValue() { - auto info = std::make_unique(); +base::Value GpuInfoAsDictionaryValue() { + base::Value info(base::Value::Type::DICTIONARY); const gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo(); const gpu::GpuFeatureInfo gpu_feature_info = @@ -359,40 +350,39 @@ std::unique_ptr GpuInfoAsDictionaryValue() { GpuDataManagerImpl::GetInstance()->GetGpuExtraInfo(); auto basic_info = BasicGpuInfoAsListValue(gpu_info, gpu_feature_info, gpu_extra_info); - info->Set("basicInfo", std::move(basic_info)); + info.SetKey("basicInfo", std::move(basic_info)); #if defined(OS_WIN) - auto dx_info = std::make_unique(); + base::Value dx_info(base::Value::Type::LIST); if (gpu_info.dx_diagnostics.children.size()) dx_info = DxDiagNodeToList(gpu_info.dx_diagnostics); - info->Set("diagnostics", std::move(dx_info)); + info.SetKey("diagnostics", std::move(dx_info)); #endif #if BUILDFLAG(ENABLE_VULKAN) if (gpu_info.vulkan_info) { auto blob = gpu_info.vulkan_info->Serialize(); - info->SetString("vulkanInfo", base::Base64Encode(blob)); + info.SetStringKey("vulkanInfo", base::Base64Encode(blob)); } #endif return info; } -std::unique_ptr CompositorInfo() { - auto compositor_info = std::make_unique(); +base::Value CompositorInfo() { + auto compositor_info = base::Value(base::Value::Type::LIST); - compositor_info->Append(NewDescriptionValuePair( + compositor_info.Append(NewDescriptionValuePair( "Tile Update Mode", IsZeroCopyUploadEnabled() ? "Zero-copy" : "One-copy")); - compositor_info->Append(NewDescriptionValuePair( + compositor_info.Append(NewDescriptionValuePair( "Partial Raster", IsPartialRasterEnabled() ? "Enabled" : "Disabled")); return compositor_info; } -std::unique_ptr GpuMemoryBufferInfo( - const gfx::GpuExtraInfo& gpu_extra_info) { - auto gpu_memory_buffer_info = std::make_unique(); +base::Value GpuMemoryBufferInfo(const gfx::GpuExtraInfo& gpu_extra_info) { + auto gpu_memory_buffer_info = base::Value(base::Value::Type::LIST); gpu::GpuMemoryBufferSupport gpu_memory_buffer_support; @@ -425,43 +415,43 @@ std::unique_ptr GpuMemoryBufferInfo( if (native_usage_support.empty()) native_usage_support = base::StringPrintf("Software only"); - gpu_memory_buffer_info->Append(NewDescriptionValuePair( + gpu_memory_buffer_info.Append(NewDescriptionValuePair( gfx::BufferFormatToString(static_cast(format)), native_usage_support)); } return gpu_memory_buffer_info; } -std::unique_ptr GetDisplayInfo() { - auto display_info = std::make_unique(); +base::Value GetDisplayInfo() { + auto display_info = base::Value(base::Value::Type::LIST); const std::vector displays = display::Screen::GetScreen()->GetAllDisplays(); for (const auto& display : displays) { - display_info->Append(NewDescriptionValuePair("Info ", display.ToString())); + display_info.Append(NewDescriptionValuePair("Info ", display.ToString())); { std::vector names; std::vector color_spaces; std::vector buffer_formats; display.color_spaces().ToStrings(&names, &color_spaces, &buffer_formats); for (size_t i = 0; i < names.size(); ++i) { - display_info->Append(NewDescriptionValuePair( + display_info.Append(NewDescriptionValuePair( base::StringPrintf("Color space (%s)", names[i].c_str()), color_spaces[i].ToString())); - display_info->Append(NewDescriptionValuePair( + display_info.Append(NewDescriptionValuePair( base::StringPrintf("Buffer format (%s)", names[i].c_str()), gfx::BufferFormatToString(buffer_formats[i]))); } } - display_info->Append(NewDescriptionValuePair( + display_info.Append(NewDescriptionValuePair( "SDR white level in nits", base::NumberToString(display.color_spaces().GetSDRWhiteLevel()))); - display_info->Append(NewDescriptionValuePair( + display_info.Append(NewDescriptionValuePair( "Bits per color component", base::NumberToString(display.depth_per_component()))); - display_info->Append(NewDescriptionValuePair( + display_info.Append(NewDescriptionValuePair( "Bits per pixel", base::NumberToString(display.color_depth()))); if (display.display_frequency()) { - display_info->Append(NewDescriptionValuePair( + display_info.Append(NewDescriptionValuePair( "Refresh Rate in Hz", base::NumberToString(display.display_frequency()))); } @@ -512,30 +502,30 @@ const char* HasDiscreteGpuToString(gpu::HasDiscreteGpu has_discrete_gpu) { } #endif // OS_WIN -std::unique_ptr GetDevicePerfInfo() { - auto list = std::make_unique(); +base::Value GetDevicePerfInfo() { + auto list = base::Value(base::Value::Type::LIST); const base::Optional device_perf_info = gpu::GetDevicePerfInfo(); if (device_perf_info.has_value()) { - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "Total Physical Memory (Gb)", base::NumberToString(device_perf_info->total_physical_memory_mb / 1024))); - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "Total Disk Space (Gb)", base::NumberToString(device_perf_info->total_disk_space_mb / 1024))); - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "Hardware Concurrency", base::NumberToString(device_perf_info->hardware_concurrency))); #if defined(OS_WIN) - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "System Commit Limit (Gb)", base::NumberToString(device_perf_info->system_commit_limit_mb / 1024))); - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "D3D11 Feature Level", D3dFeatureLevelToString(device_perf_info->d3d11_feature_level))); - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "Has Discrete GPU", HasDiscreteGpuToString(device_perf_info->has_discrete_gpu))); #endif // OS_WIN @@ -550,10 +540,10 @@ std::unique_ptr GetDevicePerfInfo() { intel_gpu_gen = base::NumberToString( static_cast(device_perf_info->intel_gpu_generation)); } - list->Append( + list.Append( NewDescriptionValuePair("Intel GPU Generation", intel_gpu_gen)); } - list->Append(NewDescriptionValuePair( + list.Append(NewDescriptionValuePair( "Software Rendering", device_perf_info->software_rendering ? "Yes" : "No")); } @@ -627,9 +617,9 @@ const char* GetProfileName(gpu::VideoCodecProfile profile) { return ""; } -std::unique_ptr GetVideoAcceleratorsInfo() { +base::Value GetVideoAcceleratorsInfo() { gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo(); - auto info = std::make_unique(); + auto info = base::Value(base::Value::Type::LIST); for (const auto& profile : gpu_info.video_decode_accelerator_capabilities.supported_profiles) { @@ -639,7 +629,7 @@ std::unique_ptr GetVideoAcceleratorsInfo() { "%s to %s pixels%s", profile.min_resolution.ToString().c_str(), profile.max_resolution.ToString().c_str(), profile.encrypted_only ? " (encrypted)" : ""); - info->Append(NewDescriptionValuePair(codec_string, resolution_string)); + info.Append(NewDescriptionValuePair(codec_string, resolution_string)); } for (const auto& profile : @@ -652,24 +642,24 @@ std::unique_ptr GetVideoAcceleratorsInfo() { profile.max_resolution.ToString().c_str(), static_cast(profile.max_framerate_numerator) / profile.max_framerate_denominator); - info->Append(NewDescriptionValuePair(codec_string, resolution_string)); + info.Append(NewDescriptionValuePair(codec_string, resolution_string)); } return info; } -std::unique_ptr GetANGLEFeatures() { +base::Value GetANGLEFeatures() { gfx::GpuExtraInfo gpu_extra_info = GpuDataManagerImpl::GetInstance()->GetGpuExtraInfo(); - auto angle_features_list = std::make_unique(); + auto angle_features_list = base::Value(base::Value::Type::LIST); for (const auto& feature : gpu_extra_info.angle_features) { - auto angle_feature = std::make_unique(); - angle_feature->SetString("name", feature.name); - angle_feature->SetString("category", feature.category); - angle_feature->SetString("description", feature.description); - angle_feature->SetString("bug", feature.bug); - angle_feature->SetString("status", feature.status); - angle_feature->SetString("condition", feature.condition); - angle_features_list->Append(std::move(angle_feature)); + auto angle_feature = base::Value(base::Value::Type::DICTIONARY); + angle_feature.SetStringKey("name", feature.name); + angle_feature.SetStringKey("category", feature.category); + angle_feature.SetStringKey("description", feature.description); + angle_feature.SetStringKey("bug", feature.bug); + angle_feature.SetStringKey("status", feature.status); + angle_feature.SetStringKey("condition", feature.condition); + angle_features_list.Append(std::move(angle_feature)); } return angle_features_list; @@ -846,50 +836,51 @@ void GpuMessageHandler::OnGpuInfoUpdate() { auto gpu_info_val = GpuInfoAsDictionaryValue(); // Add in blocklisting features - auto feature_status = std::make_unique(); - feature_status->Set("featureStatus", GetFeatureStatus()); - feature_status->Set("problems", GetProblems()); - auto workarounds = std::make_unique(); + auto feature_status = base::Value(base::Value::Type::DICTIONARY); + feature_status.SetKey("featureStatus", GetFeatureStatus()); + feature_status.SetKey("problems", GetProblems()); + auto workarounds = base::Value(base::Value::Type::LIST); for (const auto& workaround : GetDriverBugWorkarounds()) - workarounds->AppendString(workaround); - feature_status->Set("workarounds", std::move(workarounds)); - gpu_info_val->Set("featureStatus", std::move(feature_status)); + workarounds.Append(workaround); + feature_status.SetKey("workarounds", std::move(workarounds)); + gpu_info_val.SetKey("featureStatus", std::move(feature_status)); if (!GpuDataManagerImpl::GetInstance()->IsGpuProcessUsingHardwareGpu()) { const gpu::GPUInfo gpu_info_for_hardware_gpu = GpuDataManagerImpl::GetInstance()->GetGPUInfoForHardwareGpu(); if (gpu_info_for_hardware_gpu.IsInitialized()) { auto feature_status_for_hardware_gpu = - std::make_unique(); - feature_status_for_hardware_gpu->Set("featureStatus", - GetFeatureStatusForHardwareGpu()); - feature_status_for_hardware_gpu->Set("problems", - GetProblemsForHardwareGpu()); - auto workarounds_for_hardware_gpu = std::make_unique(); + base::Value(base::Value::Type::DICTIONARY); + feature_status_for_hardware_gpu.SetKey("featureStatus", + GetFeatureStatusForHardwareGpu()); + feature_status_for_hardware_gpu.SetKey("problems", + GetProblemsForHardwareGpu()); + auto workarounds_for_hardware_gpu = base::Value(base::Value::Type::LIST); for (const auto& workaround : GetDriverBugWorkaroundsForHardwareGpu()) - workarounds_for_hardware_gpu->AppendString(workaround); - feature_status_for_hardware_gpu->Set( + workarounds_for_hardware_gpu.Append(workaround); + feature_status_for_hardware_gpu.SetKey( "workarounds", std::move(workarounds_for_hardware_gpu)); - gpu_info_val->Set("featureStatusForHardwareGpu", - std::move(feature_status_for_hardware_gpu)); + gpu_info_val.SetKey("featureStatusForHardwareGpu", + std::move(feature_status_for_hardware_gpu)); const gpu::GpuFeatureInfo gpu_feature_info_for_hardware_gpu = GpuDataManagerImpl::GetInstance()->GetGpuFeatureInfoForHardwareGpu(); auto gpu_info_for_hardware_gpu_val = BasicGpuInfoAsListValue( gpu_info_for_hardware_gpu, gpu_feature_info_for_hardware_gpu, gfx::GpuExtraInfo{}); - gpu_info_val->Set("basicInfoForHardwareGpu", - std::move(gpu_info_for_hardware_gpu_val)); + gpu_info_val.SetKey("basicInfoForHardwareGpu", + std::move(gpu_info_for_hardware_gpu_val)); } } - gpu_info_val->Set("compositorInfo", CompositorInfo()); - gpu_info_val->Set("gpuMemoryBufferInfo", GpuMemoryBufferInfo(gpu_extra_info)); - gpu_info_val->Set("displayInfo", GetDisplayInfo()); - gpu_info_val->Set("videoAcceleratorsInfo", GetVideoAcceleratorsInfo()); - gpu_info_val->Set("ANGLEFeatures", GetANGLEFeatures()); - gpu_info_val->Set("devicePerfInfo", GetDevicePerfInfo()); + gpu_info_val.SetKey("compositorInfo", CompositorInfo()); + gpu_info_val.SetKey("gpuMemoryBufferInfo", + GpuMemoryBufferInfo(gpu_extra_info)); + gpu_info_val.SetKey("displayInfo", GetDisplayInfo()); + gpu_info_val.SetKey("videoAcceleratorsInfo", GetVideoAcceleratorsInfo()); + gpu_info_val.SetKey("ANGLEFeatures", GetANGLEFeatures()); + gpu_info_val.SetKey("devicePerfInfo", GetDevicePerfInfo()); // Send GPU Info to javascript. web_ui()->CallJavascriptFunctionUnsafe("browserBridge.onGpuInfoUpdate", - *(gpu_info_val.get())); + gpu_info_val); } void GpuMessageHandler::OnGpuSwitched(gl::GpuPreference active_gpu_heuristic) { diff --git a/content/browser/tracing/tracing_controller_impl.cc b/content/browser/tracing/tracing_controller_impl.cc index bce76c9a840a2..3f9925b693c40 100644 --- a/content/browser/tracing/tracing_controller_impl.cc +++ b/content/browser/tracing/tracing_controller_impl.cc @@ -337,7 +337,9 @@ TracingControllerImpl::GenerateMetadataDict() { metadata_dict->SetString("gpu-gl-vendor", gpu_info.gl_vendor); metadata_dict->SetString("gpu-gl-renderer", gpu_info.gl_renderer); #endif - metadata_dict->SetDictionary("gpu-features", GetFeatureStatus()); + metadata_dict->SetDictionary( + "gpu-features", base::DictionaryValue::From( + std::make_unique(GetFeatureStatus()))); metadata_dict->SetString("clock-domain", GetClockString()); metadata_dict->SetBoolean("highres-ticks", diff --git a/gpu/config/BUILD.gn b/gpu/config/BUILD.gn index 9b8c22905588d..0934432eb5582 100644 --- a/gpu/config/BUILD.gn +++ b/gpu/config/BUILD.gn @@ -178,6 +178,7 @@ source_set("config_sources") { deps = [ ":process_json", "//base", + "//base/util/values:values_util", "//build:branding_buildflags", "//build:chromecast_buildflags", "//build:chromeos_buildflags", diff --git a/gpu/config/gpu_control_list.cc b/gpu/config/gpu_control_list.cc index 9db98fb1e0e74..fbb9f58f29996 100644 --- a/gpu/config/gpu_control_list.cc +++ b/gpu/config/gpu_control_list.cc @@ -14,6 +14,7 @@ #include "base/strings/string_util.h" #include "base/strings/stringprintf.h" #include "base/system/sys_info.h" +#include "base/util/values/values_util.h" #include "base/values.h" #include "build/build_config.h" #include "build/chromeos_buildflags.h" @@ -601,18 +602,17 @@ bool GpuControlList::Entry::NeedsMoreInfo(const GPUInfo& gpu_info, } void GpuControlList::Entry::GetFeatureNames( - base::ListValue* feature_names, + base::Value& feature_names, const FeatureMap& feature_map) const { - DCHECK(feature_names); for (size_t ii = 0; ii < feature_size; ++ii) { auto iter = feature_map.find(features[ii]); DCHECK(iter != feature_map.end()); - feature_names->AppendString(iter->second); + feature_names.Append(iter->second); } for (size_t ii = 0; ii < disabled_extension_size; ++ii) { std::string name = base::StringPrintf("disable(%s)", disabled_extensions[ii]); - feature_names->AppendString(name); + feature_names.Append(name); } } @@ -738,30 +738,30 @@ std::vector GpuControlList::GetDisabledWebGLExtensions() { disabled_webgl_extensions.end()); } -void GpuControlList::GetReasons(base::ListValue* problem_list, +void GpuControlList::GetReasons(base::Value& problem_list, const std::string& tag, const std::vector& entries) const { - DCHECK(problem_list); for (auto index : entries) { DCHECK_LT(index, entry_count_); const Entry& entry = entries_[index]; - auto problem = std::make_unique(); + auto problem = base::Value(base::Value::Type::DICTIONARY); - problem->SetString("description", entry.description); + problem.SetStringKey("description", entry.description); - auto cr_bugs = std::make_unique(); + auto cr_bugs = base::Value(base::Value::Type::LIST); for (size_t jj = 0; jj < entry.cr_bug_size; ++jj) - cr_bugs->AppendInteger(entry.cr_bugs[jj]); - problem->Set("crBugs", std::move(cr_bugs)); + cr_bugs.Append( + util::Int64ToValue(static_cast(entry.cr_bugs[jj]))); + problem.SetKey("crBugs", std::move(cr_bugs)); - auto features = std::make_unique(); - entry.GetFeatureNames(features.get(), feature_map_); - problem->Set("affectedGpuSettings", std::move(features)); + auto features = base::Value(base::Value::Type::LIST); + entry.GetFeatureNames(features, feature_map_); + problem.SetKey("affectedGpuSettings", std::move(features)); DCHECK(tag == "workarounds" || tag == "disabledFeatures"); - problem->SetString("tag", tag); + problem.SetStringKey("tag", tag); - problem_list->Append(std::move(problem)); + problem_list.Append(std::move(problem)); } } diff --git a/gpu/config/gpu_control_list.h b/gpu/config/gpu_control_list.h index 8a27b1c2bc752..ebc5183bee5f9 100644 --- a/gpu/config/gpu_control_list.h +++ b/gpu/config/gpu_control_list.h @@ -240,7 +240,7 @@ class GPU_EXPORT GpuControlList { // decision. It should only be checked if Contains() returns true. bool NeedsMoreInfo(const GPUInfo& gpu_info, bool consider_exceptions) const; - void GetFeatureNames(base::ListValue* feature_names, + void GetFeatureNames(base::Value& feature_names, const FeatureMap& feature_map) const; // Logs a control list match for this rule in the list identified by @@ -287,7 +287,7 @@ class GPU_EXPORT GpuControlList { // } // The use case is we compute the entries from GPU process and send them to // browser process, and call GetReasons() in browser process. - void GetReasons(base::ListValue* problem_list, + void GetReasons(base::Value& problem_list, const std::string& tag, const std::vector& entries) const;