mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

chore: modernize ListValue usage in gpu info (#34663)

Browse source
This commit is contained in:
Jeremy Rose 2022-06-28 09:52:59 -07:00 committed by GitHub
parent a4043237da
commit 07294cbf15
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 71 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
shell/browser/api/electron_api_app.cc
View file

@ -1443,7 +1443,7 @@ v8::Local<v8::Value> App::GetGPUFeatureStatus(v8::Isolate* isolate) {
v8::Local<v8::Promise> App::GetGPUInfo(v8::Isolate* isolate,
const std::string& info_type) {
auto* const gpu_data_manager = content::GpuDataManagerImpl::GetInstance();
gin_helper::Promise<base::DictionaryValue> promise(isolate);
gin_helper::Promise<base::Value> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (info_type != "basic" && info_type != "complete") {
promise.RejectWithErrorMessage(

112
shell/browser/api/gpu_info_enumerator.cc
View file

@ -8,127 +8,125 @@
namespace electron {
GPUInfoEnumerator::GPUInfoEnumerator()
: value_stack(), current(std::make_unique<base::DictionaryValue>()) {}
GPUInfoEnumerator::GPUInfoEnumerator() : value_stack_(), current_{} {}
GPUInfoEnumerator::~GPUInfoEnumerator() = default;
void GPUInfoEnumerator::AddInt64(const char* name, int64_t value) {
current->SetInteger(name, value);
// NOTE(nornagon): this loses precision. base::Value can't store int64_t.
current_.Set(name, static_cast<int>(value));
}
void GPUInfoEnumerator::AddInt(const char* name, int value) {
current->SetInteger(name, value);
current_.Set(name, value);
}
void GPUInfoEnumerator::AddString(const char* name, const std::string& value) {
if (!value.empty())
current->SetString(name, value);
current_.Set(name, value);
}
void GPUInfoEnumerator::AddBool(const char* name, bool value) {
current->SetBoolean(name, value);
current_.Set(name, value);
}
void GPUInfoEnumerator::AddTimeDeltaInSecondsF(const char* name,
const base::TimeDelta& value) {
current->SetInteger(name, value.InMilliseconds());
current_.Set(name, value.InMillisecondsF());
}
void GPUInfoEnumerator::AddBinary(const char* name,
const base::span<const uint8_t>& value) {
current->Set(name, std::make_unique<base::Value>(value));
current_.Set(name, base::Value(value));
}
void GPUInfoEnumerator::BeginGPUDevice() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
value_stack_.push(std::move(current_));
current_ = {};
}
void GPUInfoEnumerator::EndGPUDevice() {
auto& top_value = value_stack.top();
auto& top_value = value_stack_.top();
// GPUDevice can be more than one. So create a list of all.
// The first one is the active GPU device.
if (top_value->FindKey(kGPUDeviceKey)) {
base::ListValue* list;
top_value->GetList(kGPUDeviceKey, &list);
list->Append(base::Value::FromUniquePtrValue(std::move(current)));
if (base::Value* list_value = top_value.Find(kGPUDeviceKey)) {
DCHECK(list_value->is_list());
base::Value::List& list = list_value->GetList();
list.Append(std::move(current_));
} else {
std::unique_ptr<base::ListValue> gpus(new base::ListValue());
gpus->Append(base::Value::FromUniquePtrValue(std::move(current)));
top_value->SetList(kGPUDeviceKey, std::move(gpus));
base::Value::List gpus;
gpus.Append(std::move(current_));
top_value.Set(kGPUDeviceKey, std::move(gpus));
}
current = std::move(top_value);
value_stack.pop();
current_ = std::move(top_value);
value_stack_.pop();
}
void GPUInfoEnumerator::BeginVideoDecodeAcceleratorSupportedProfile() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
value_stack_.push(std::move(current_));
current_ = {};
}
void GPUInfoEnumerator::EndVideoDecodeAcceleratorSupportedProfile() {
auto& top_value = value_stack.top();
top_value->SetKey(kVideoDecodeAcceleratorSupportedProfileKey,
base::Value::FromUniquePtrValue(std::move(current)));
current = std::move(top_value);
value_stack.pop();
auto& top_value = value_stack_.top();
top_value.Set(kVideoDecodeAcceleratorSupportedProfileKey,
std::move(current_));
current_ = std::move(top_value);
value_stack_.pop();
}
void GPUInfoEnumerator::BeginVideoEncodeAcceleratorSupportedProfile() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
value_stack_.push(std::move(current_));
current_ = {};
}
void GPUInfoEnumerator::EndVideoEncodeAcceleratorSupportedProfile() {
auto& top_value = value_stack.top();
top_value->SetKey(kVideoEncodeAcceleratorSupportedProfileKey,
base::Value::FromUniquePtrValue(std::move(current)));
current = std::move(top_value);
value_stack.pop();
auto& top_value = value_stack_.top();
top_value.Set(kVideoEncodeAcceleratorSupportedProfileKey,
std::move(current_));
current_ = std::move(top_value);
value_stack_.pop();
}
void GPUInfoEnumerator::BeginImageDecodeAcceleratorSupportedProfile() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
value_stack_.push(std::move(current_));
current_ = {};
}
void GPUInfoEnumerator::EndImageDecodeAcceleratorSupportedProfile() {
auto& top_value = value_stack.top();
top_value->SetKey(kImageDecodeAcceleratorSupportedProfileKey,
base::Value::FromUniquePtrValue(std::move(current)));
current = std::move(top_value);
value_stack.pop();
auto& top_value = value_stack_.top();
top_value.Set(kImageDecodeAcceleratorSupportedProfileKey,
std::move(current_));
current_ = std::move(top_value);
value_stack_.pop();
}
void GPUInfoEnumerator::BeginAuxAttributes() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
value_stack_.push(std::move(current_));
current_ = {};
}
void GPUInfoEnumerator::EndAuxAttributes() {
auto& top_value = value_stack.top();
top_value->SetKey(kAuxAttributesKey,
base::Value::FromUniquePtrValue(std::move(current)));
current = std::move(top_value);
value_stack.pop();
auto& top_value = value_stack_.top();
top_value.Set(kAuxAttributesKey, std::move(current_));
current_ = std::move(top_value);
value_stack_.pop();
}
void GPUInfoEnumerator::BeginOverlayInfo() {
value_stack.push(std::move(current));
current = std::make_unique<base::DictionaryValue>();
value_stack_.push(std::move(current_));
current_ = {};
}
void GPUInfoEnumerator::EndOverlayInfo() {
auto& top_value = value_stack.top();
top_value->SetKey(kOverlayInfo,
base::Value::FromUniquePtrValue(std::move(current)));
current = std::move(top_value);
value_stack.pop();
auto& top_value = value_stack_.top();
top_value.Set(kOverlayInfo, std::move(current_));
current_ = std::move(top_value);
value_stack_.pop();
}
std::unique_ptr<base::DictionaryValue> GPUInfoEnumerator::GetDictionary() {
return std::move(current);
base::Value::Dict GPUInfoEnumerator::GetDictionary() {
return std::move(current_);
}
} // namespace electron

6
shell/browser/api/gpu_info_enumerator.h
View file

@ -50,12 +50,12 @@ class GPUInfoEnumerator final : public gpu::GPUInfo::Enumerator {
void EndAuxAttributes() override;
void BeginOverlayInfo() override;
void EndOverlayInfo() override;
std::unique_ptr<base::DictionaryValue> GetDictionary();
base::Value::Dict GetDictionary();
private:
// The stack is used to manage nested values
std::stack<std::unique_ptr<base::DictionaryValue>> value_stack;
std::unique_ptr<base::DictionaryValue> current;
std::stack<base::Value::Dict> value_stack_;
base::Value::Dict current_;
};
} // namespace electron

15
shell/browser/api/gpuinfo_manager.cc
View file

@ -41,11 +41,11 @@ bool GPUInfoManager::NeedsCompleteGpuInfoCollection() const {
// Should be posted to the task runner
void GPUInfoManager::ProcessCompleteInfo() {
const auto result = EnumerateGPUInfo(gpu_data_manager_->GetGPUInfo());
base::Value::Dict result = EnumerateGPUInfo(gpu_data_manager_->GetGPUInfo());
// We have received the complete information, resolve all promises that
// were waiting for this info.
for (auto& promise : complete_info_promise_set_) {
promise.Resolve(*result);
promise.Resolve(base::Value(result.Clone()));
}
complete_info_promise_set_.clear();
}
@ -61,7 +61,7 @@ void GPUInfoManager::OnGpuInfoUpdate() {
// Should be posted to the task runner
void GPUInfoManager::CompleteInfoFetcher(
gin_helper::Promise<base::DictionaryValue> promise) {
gin_helper::Promise<base::Value> promise) {
complete_info_promise_set_.emplace_back(std::move(promise));
if (NeedsCompleteGpuInfoCollection()) {
@ -73,7 +73,7 @@ void GPUInfoManager::CompleteInfoFetcher(
}
void GPUInfoManager::FetchCompleteInfo(
gin_helper::Promise<base::DictionaryValue> promise) {
gin_helper::Promise<base::Value> promise) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&GPUInfoManager::CompleteInfoFetcher,
base::Unretained(this), std::move(promise)));
@ -81,14 +81,13 @@ void GPUInfoManager::FetchCompleteInfo(
// This fetches the info synchronously, so no need to post to the task queue.
// There cannot be multiple promises as they are resolved synchronously.
void GPUInfoManager::FetchBasicInfo(
gin_helper::Promise<base::DictionaryValue> promise) {
void GPUInfoManager::FetchBasicInfo(gin_helper::Promise<base::Value> promise) {
gpu::GPUInfo gpu_info;
CollectBasicGraphicsInfo(&gpu_info);
promise.Resolve(*EnumerateGPUInfo(gpu_info));
promise.Resolve(base::Value(EnumerateGPUInfo(gpu_info)));
}
std::unique_ptr<base::DictionaryValue> GPUInfoManager::EnumerateGPUInfo(
base::Value::Dict GPUInfoManager::EnumerateGPUInfo(
gpu::GPUInfo gpu_info) const {
GPUInfoEnumerator enumerator;
gpu_info.EnumerateFields(&enumerator);

12
shell/browser/api/gpuinfo_manager.h
View file

@ -28,22 +28,20 @@ class GPUInfoManager : public content::GpuDataManagerObserver {
GPUInfoManager& operator=(const GPUInfoManager&) = delete;
bool NeedsCompleteGpuInfoCollection() const;
void FetchCompleteInfo(gin_helper::Promise<base::DictionaryValue> promise);
void FetchBasicInfo(gin_helper::Promise<base::DictionaryValue> promise);
void FetchCompleteInfo(gin_helper::Promise<base::Value> promise);
void FetchBasicInfo(gin_helper::Promise<base::Value> promise);
void OnGpuInfoUpdate() override;
private:
std::unique_ptr<base::DictionaryValue> EnumerateGPUInfo(
gpu::GPUInfo gpu_info) const;
base::Value::Dict EnumerateGPUInfo(gpu::GPUInfo gpu_info) const;
// These should be posted to the task queue
void CompleteInfoFetcher(gin_helper::Promise<base::DictionaryValue> promise);
void CompleteInfoFetcher(gin_helper::Promise<base::Value> promise);
void ProcessCompleteInfo();
// This set maintains all the promises that should be fulfilled
// once we have the complete information data
std::vector<gin_helper::Promise<base::DictionaryValue>>
complete_info_promise_set_;
std::vector<gin_helper::Promise<base::Value>> complete_info_promise_set_;
content::GpuDataManagerImpl* gpu_data_manager_;
};