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

refactor: make util::Promise type safe when chaining in native (#19809)

Browse source 
* refactor: make util::Promise type safe when chaining in native

* fixup! refactor: make util::Promise type safe when chaining in native

* chore: remove spare brackets
This commit is contained in:
Samuel Attard 2019-08-22 17:03:28 -07:00 • committed by GitHub
parent f7e3e1f97a
commit 6a3922d330
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
39 changed files with 275 additions and 343 deletions
Download patch file Download diff file Expand all files Collapse all files

6
shell/browser/api/atom_api_app.cc
View file

@ -532,7 +532,7 @@ int ImportIntoCertStore(CertificateManagerModel* model,
}
#endif
void OnIconDataAvailable(util::Promise promise, gfx::Image icon) {
void OnIconDataAvailable(util::Promise<gfx::Image> promise, gfx::Image icon) {
if (!icon.IsEmpty()) {
promise.Resolve(icon);
} else {
@ -1167,7 +1167,7 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
v8::Local<v8::Promise> App::GetFileIcon(const base::FilePath& path,
mate::Arguments* args) {
util::Promise promise(isolate());
util::Promise<gfx::Image> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
base::FilePath normalized_path = path.NormalizePathSeparators();
@ -1272,7 +1272,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();
util::Promise promise(isolate);
util::Promise<base::DictionaryValue> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (info_type != "basic" && info_type != "complete") {
promise.RejectWithErrorMessage(

27
shell/browser/api/atom_api_content_tracing.cc
View file

@ -64,13 +64,13 @@ base::Optional<base::FilePath> CreateTemporaryFileOnIO() {
return base::make_optional(std::move(temp_file_path));
}
void StopTracing(electron::util::Promise promise,
void StopTracing(electron::util::Promise<base::FilePath> promise,
base::Optional<base::FilePath> file_path) {
if (file_path) {
auto endpoint = TracingController::CreateFileEndpoint(
*file_path,
base::AdaptCallbackForRepeating(base::BindOnce(
&electron::util::Promise::ResolvePromise<base::FilePath>,
&electron::util::Promise<base::FilePath>::ResolvePromise,
std::move(promise), *file_path)));
TracingController::GetInstance()->StopTracing(endpoint);
} else {
@ -80,7 +80,7 @@ void StopTracing(electron::util::Promise promise,
}
v8::Local<v8::Promise> StopRecording(mate::Arguments* args) {
electron::util::Promise promise(args->isolate());
electron::util::Promise<base::FilePath> promise(args->isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
base::FilePath path;
@ -98,12 +98,12 @@ v8::Local<v8::Promise> StopRecording(mate::Arguments* args) {
}
v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
electron::util::Promise promise(isolate);
electron::util::Promise<const std::set<std::string>&> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
// Note: This method always succeeds.
TracingController::GetInstance()->GetCategories(base::BindOnce(
electron::util::Promise::ResolvePromise<const std::set<std::string>&>,
electron::util::Promise<const std::set<std::string>&>::ResolvePromise,
std::move(promise)));
return handle;
@ -112,34 +112,35 @@ v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
v8::Local<v8::Promise> StartTracing(
v8::Isolate* isolate,
const base::trace_event::TraceConfig& trace_config) {
electron::util::Promise promise(isolate);
electron::util::Promise<void*> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (!TracingController::GetInstance()->StartTracing(
trace_config,
base::BindOnce(electron::util::Promise::ResolveEmptyPromise,
base::BindOnce(electron::util::Promise<void*>::ResolveEmptyPromise,
std::move(promise)))) {
// If StartTracing returns false, that means it didn't invoke its callback.
// Return an already-resolved promise and abandon the previous promise (it
// was std::move()d into the StartTracing callback and has been deleted by
// this point).
return electron::util::Promise::ResolvedPromise(isolate);
return electron::util::Promise<void*>::ResolvedPromise(isolate);
}
return handle;
}
void OnTraceBufferUsageAvailable(electron::util::Promise promise,
float percent_full,
size_t approximate_count) {
void OnTraceBufferUsageAvailable(
electron::util::Promise<mate::Dictionary> promise,
float percent_full,
size_t approximate_count) {
mate::Dictionary dict = mate::Dictionary::CreateEmpty(promise.isolate());
dict.Set("percentage", percent_full);
dict.Set("value", approximate_count);
promise.Resolve(dict.GetHandle());
promise.Resolve(dict);
}
v8::Local<v8::Promise> GetTraceBufferUsage(v8::Isolate* isolate) {
electron::util::Promise promise(isolate);
electron::util::Promise<mate::Dictionary> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
// Note: This method always succeeds.

22
shell/browser/api/atom_api_cookies.cc
View file

@ -121,7 +121,7 @@ bool MatchesCookie(const base::Value& filter,
// Remove cookies from |list| not matching |filter|, and pass it to |callback|.
void FilterCookies(const base::Value& filter,
util::Promise promise,
util::Promise<net::CookieList> promise,
const net::CookieList& list,
const net::CookieStatusList& excluded_list) {
net::CookieList result;
@ -130,7 +130,7 @@ void FilterCookies(const base::Value& filter,
result.push_back(cookie);
}
promise.Resolve(gin::ConvertToV8(promise.isolate(), result));
promise.ResolveWithGin(result);
}
std::string InclusionStatusToString(
@ -170,7 +170,7 @@ Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
Cookies::~Cookies() {}
v8::Local<v8::Promise> Cookies::Get(const base::DictionaryValue& filter) {
util::Promise promise(isolate());
util::Promise<net::CookieList> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
std::string url_string;
@ -206,7 +206,7 @@ v8::Local<v8::Promise> Cookies::Get(const base::DictionaryValue& filter) {
v8::Local<v8::Promise> Cookies::Remove(const GURL& url,
const std::string& name) {
util::Promise promise(isolate());
util::Promise<void*> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto cookie_deletion_filter = network::mojom::CookieDeletionFilter::New();
@ -220,8 +220,8 @@ v8::Local<v8::Promise> Cookies::Remove(const GURL& url,
manager->DeleteCookies(
std::move(cookie_deletion_filter),
base::BindOnce(
[](util::Promise promise, uint32_t num_deleted) {
util::Promise::ResolveEmptyPromise(std::move(promise));
[](util::Promise<void*> promise, uint32_t num_deleted) {
util::Promise<void*>::ResolveEmptyPromise(std::move(promise));
},
std::move(promise)));
@ -229,7 +229,7 @@ v8::Local<v8::Promise> Cookies::Remove(const GURL& url,
}
v8::Local<v8::Promise> Cookies::Set(const base::DictionaryValue& details) {
util::Promise promise(isolate());
util::Promise<void*> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
const std::string* url_string = details.FindStringKey("url");
@ -288,7 +288,7 @@ v8::Local<v8::Promise> Cookies::Set(const base::DictionaryValue& details) {
manager->SetCanonicalCookie(
*canonical_cookie, url.scheme(), options,
base::BindOnce(
[](util::Promise promise,
[](util::Promise<void*> promise,
net::CanonicalCookie::CookieInclusionStatus status) {
auto errmsg = InclusionStatusToString(status);
if (errmsg.empty()) {
@ -303,15 +303,15 @@ v8::Local<v8::Promise> Cookies::Set(const base::DictionaryValue& details) {
}
v8::Local<v8::Promise> Cookies::FlushStore() {
util::Promise promise(isolate());
util::Promise<void*> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto* storage_partition = content::BrowserContext::GetDefaultStoragePartition(
browser_context_.get());
auto* manager = storage_partition->GetCookieManagerForBrowserProcess();
manager->FlushCookieStore(
base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
manager->FlushCookieStore(base::BindOnce(
util::Promise<void*>::ResolveEmptyPromise, std::move(promise)));
return handle;
}

5
shell/browser/api/atom_api_debugger.cc
View file

@ -65,7 +65,8 @@ void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
if (it == pending_requests_.end())
return;
electron::util::Promise promise = std::move(it->second);
electron::util::Promise<base::DictionaryValue> promise =
std::move(it->second);
pending_requests_.erase(it);
base::DictionaryValue* error = nullptr;
@ -129,7 +130,7 @@ void Debugger::Detach() {
}
v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
electron::util::Promise promise(isolate());
electron::util::Promise<base::DictionaryValue> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
if (!agent_host_) {

3
shell/browser/api/atom_api_debugger.h
View file

@ -54,7 +54,8 @@ class Debugger : public mate::TrackableObject<Debugger>,
content::RenderFrameHost* new_rfh) override;
private:
using PendingRequestMap = std::map<int, electron::util::Promise>;
using PendingRequestMap =
std::map<int, electron::util::Promise<base::DictionaryValue>>;
void Attach(mate::Arguments* args);
bool IsAttached();

10
shell/browser/api/atom_api_dialog.cc
View file

@ -24,7 +24,7 @@ int ShowMessageBoxSync(const electron::MessageBoxSettings& settings) {
return electron::ShowMessageBoxSync(settings);
}
void ResolvePromiseObject(electron::util::Promise promise,
void ResolvePromiseObject(electron::util::Promise<gin::Dictionary> promise,
int result,
bool checkbox_checked) {
v8::Isolate* isolate = promise.isolate();
@ -33,14 +33,14 @@ void ResolvePromiseObject(electron::util::Promise promise,
dict.Set("response", result);
dict.Set("checkboxChecked", checkbox_checked);
promise.Resolve(gin::ConvertToV8(isolate, dict));
promise.ResolveWithGin(dict);
}
v8::Local<v8::Promise> ShowMessageBox(
const electron::MessageBoxSettings& settings,
gin::Arguments* args) {
v8::Isolate* isolate = args->isolate();
electron::util::Promise promise(isolate);
electron::util::Promise<gin::Dictionary> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
electron::ShowMessageBox(
@ -59,7 +59,7 @@ void ShowOpenDialogSync(const file_dialog::DialogSettings& settings,
v8::Local<v8::Promise> ShowOpenDialog(
const file_dialog::DialogSettings& settings,
gin::Arguments* args) {
electron::util::Promise promise(args->isolate());
electron::util::Promise<mate::Dictionary> promise(args->isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
file_dialog::ShowOpenDialog(settings, std::move(promise));
return handle;
@ -75,7 +75,7 @@ void ShowSaveDialogSync(const file_dialog::DialogSettings& settings,
v8::Local<v8::Promise> ShowSaveDialog(
const file_dialog::DialogSettings& settings,
gin::Arguments* args) {
electron::util::Promise promise(args->isolate());
electron::util::Promise<mate::Dictionary> promise(args->isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
file_dialog::ShowSaveDialog(settings, std::move(promise));

14
shell/browser/api/atom_api_in_app_purchase.cc
View file

@ -104,7 +104,7 @@ v8::Local<v8::Promise> InAppPurchase::PurchaseProduct(
const std::string& product_id,
mate::Arguments* args) {
v8::Isolate* isolate = args->isolate();
electron::util::Promise promise(isolate);
electron::util::Promise<bool> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
int quantity = 1;
@ -112,7 +112,7 @@ v8::Local<v8::Promise> InAppPurchase::PurchaseProduct(
in_app_purchase::PurchaseProduct(
product_id, quantity,
base::BindOnce(electron::util::Promise::ResolvePromise<bool>,
base::BindOnce(electron::util::Promise<bool>::ResolvePromise,
std::move(promise)));
return handle;
@ -122,13 +122,15 @@ v8::Local<v8::Promise> InAppPurchase::GetProducts(
const std::vector<std::string>& productIDs,
mate::Arguments* args) {
v8::Isolate* isolate = args->isolate();
electron::util::Promise promise(isolate);
electron::util::Promise<std::vector<in_app_purchase::Product>> promise(
isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
in_app_purchase::GetProducts(
productIDs, base::BindOnce(electron::util::Promise::ResolvePromise<
std::vector<in_app_purchase::Product>>,
std::move(promise)));
productIDs,
base::BindOnce(electron::util::Promise<
std::vector<in_app_purchase::Product>>::ResolvePromise,
std::move(promise)));
return handle;
}

8
shell/browser/api/atom_api_net_log.cc
View file

@ -64,7 +64,7 @@ base::File OpenFileForWriting(base::FilePath path) {
base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
}
void ResolvePromiseWithNetError(util::Promise promise, int32_t error) {
void ResolvePromiseWithNetError(util::Promise<void*> promise, int32_t error) {
if (error == net::OK) {
promise.Resolve();
} else {
@ -119,7 +119,7 @@ v8::Local<v8::Promise> NetLog::StartLogging(base::FilePath log_path,
return v8::Local<v8::Promise>();
}
pending_start_promise_ = base::make_optional<util::Promise>(isolate());
pending_start_promise_ = base::make_optional<util::Promise<void*>>(isolate());
v8::Local<v8::Promise> handle = pending_start_promise_->GetHandle();
auto command_line_string =
@ -189,7 +189,7 @@ bool NetLog::IsCurrentlyLogging() const {
}
v8::Local<v8::Promise> NetLog::StopLogging(mate::Arguments* args) {
util::Promise promise(isolate());
util::Promise<void*> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
if (net_log_exporter_) {
@ -199,7 +199,7 @@ v8::Local<v8::Promise> NetLog::StopLogging(mate::Arguments* args) {
net_log_exporter_->Stop(
base::Value(base::Value::Type::DICTIONARY),
base::BindOnce(
[](network::mojom::NetLogExporterPtr, util::Promise promise,
[](network::mojom::NetLogExporterPtr, util::Promise<void*> promise,
int32_t error) {
ResolvePromiseWithNetError(std::move(promise), error);
},

2
shell/browser/api/atom_api_net_log.h
View file

@ -53,7 +53,7 @@ class NetLog : public mate::TrackableObject<NetLog> {
network::mojom::NetLogExporterPtr net_log_exporter_;
base::Optional<util::Promise> pending_start_promise_;
base::Optional<util::Promise<void*>> pending_start_promise_;
scoped_refptr<base::TaskRunner> file_task_runner_;

23
shell/browser/api/atom_api_protocol_ns.cc
View file

@ -232,18 +232,17 @@ v8::Local<v8::Promise> ProtocolNS::IsProtocolHandled(const std::string& scheme,
"protocol.isProtocolRegistered or protocol.isProtocolIntercepted "
"instead.",
"ProtocolDeprecateIsProtocolHandled");
util::Promise promise(isolate());
promise.Resolve(IsProtocolRegistered(scheme) ||
IsProtocolIntercepted(scheme) ||
// The |isProtocolHandled| should return true for builtin
// schemes, however with NetworkService it is impossible to
// know which schemes are registered until a real network
// request is sent.
// So we have to test against a hard-coded builtin schemes
// list make it work with old code. We should deprecate this
// API with the new |isProtocolRegistered| API.
base::Contains(kBuiltinSchemes, scheme));
return promise.GetHandle();
return util::Promise<bool>::ResolvedPromise(
isolate(), IsProtocolRegistered(scheme) ||
IsProtocolIntercepted(scheme) ||
// The |isProtocolHandled| should return true for builtin
// schemes, however with NetworkService it is impossible to
// know which schemes are registered until a real network
// request is sent.
// So we have to test against a hard-coded builtin schemes
// list make it work with old code. We should deprecate
// this API with the new |isProtocolRegistered| API.
base::Contains(kBuiltinSchemes, scheme));
}
void ProtocolNS::HandleOptionalCallback(mate::Arguments* args,

61
shell/browser/api/atom_api_session.cc
View file

@ -236,14 +236,14 @@ void Session::OnDownloadCreated(content::DownloadManager* manager,
v8::Local<v8::Promise> Session::ResolveProxy(mate::Arguments* args) {
v8::Isolate* isolate = args->isolate();
util::Promise promise(isolate);
util::Promise<std::string> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
GURL url;
args->GetNext(&url);
browser_context_->GetResolveProxyHelper()->ResolveProxy(
url, base::BindOnce(util::Promise::ResolvePromise<std::string>,
url, base::BindOnce(util::Promise<std::string>::ResolvePromise,
std::move(promise)));
return handle;
@ -251,36 +251,37 @@ v8::Local<v8::Promise> Session::ResolveProxy(mate::Arguments* args) {
v8::Local<v8::Promise> Session::GetCacheSize() {
auto* isolate = v8::Isolate::GetCurrent();
auto promise = util::Promise(isolate);
util::Promise<int64_t> promise(isolate);
auto handle = promise.GetHandle();
content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
->GetNetworkContext()
->ComputeHttpCacheSize(base::Time(), base::Time::Max(),
base::BindOnce(
[](util::Promise promise, bool is_upper_bound,
int64_t size_or_error) {
if (size_or_error < 0) {
promise.RejectWithErrorMessage(
net::ErrorToString(size_or_error));
} else {
promise.Resolve(size_or_error);
}
},
std::move(promise)));
->ComputeHttpCacheSize(
base::Time(), base::Time::Max(),
base::BindOnce(
[](util::Promise<int64_t> promise, bool is_upper_bound,
int64_t size_or_error) {
if (size_or_error < 0) {
promise.RejectWithErrorMessage(
net::ErrorToString(size_or_error));
} else {
promise.Resolve(size_or_error);
}
},
std::move(promise)));
return handle;
}
v8::Local<v8::Promise> Session::ClearCache() {
auto* isolate = v8::Isolate::GetCurrent();
auto promise = util::Promise(isolate);
util::Promise<void*> promise(isolate);
auto handle = promise.GetHandle();
content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
->GetNetworkContext()
->ClearHttpCache(base::Time(), base::Time::Max(), nullptr,
base::BindOnce(util::Promise::ResolveEmptyPromise,
base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
std::move(promise)));
return handle;
@ -288,7 +289,7 @@ v8::Local<v8::Promise> Session::ClearCache() {
v8::Local<v8::Promise> Session::ClearStorageData(mate::Arguments* args) {
v8::Isolate* isolate = args->isolate();
util::Promise promise(isolate);
util::Promise<void*> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
ClearStorageDataOptions options;
@ -305,7 +306,8 @@ v8::Local<v8::Promise> Session::ClearStorageData(mate::Arguments* args) {
storage_partition->ClearData(
options.storage_types, options.quota_types, options.origin, base::Time(),
base::Time::Max(),
base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
std::move(promise)));
return handle;
}
@ -317,7 +319,7 @@ void Session::FlushStorageData() {
v8::Local<v8::Promise> Session::SetProxy(mate::Arguments* args) {
v8::Isolate* isolate = args->isolate();
util::Promise promise(isolate);
util::Promise<void*> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
mate::Dictionary options;
@ -350,8 +352,8 @@ v8::Local<v8::Promise> Session::SetProxy(mate::Arguments* args) {
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(util::Promise::ResolveEmptyPromise, std::move(promise)));
FROM_HERE, base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
std::move(promise)));
return handle;
}
@ -449,13 +451,13 @@ void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val,
v8::Local<v8::Promise> Session::ClearHostResolverCache(mate::Arguments* args) {
v8::Isolate* isolate = args->isolate();
util::Promise promise(isolate);
util::Promise<void*> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
->GetNetworkContext()
->ClearHostCache(nullptr,
base::BindOnce(util::Promise::ResolveEmptyPromise,
base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
std::move(promise)));
return handle;
@ -463,14 +465,15 @@ v8::Local<v8::Promise> Session::ClearHostResolverCache(mate::Arguments* args) {
v8::Local<v8::Promise> Session::ClearAuthCache() {
auto* isolate = v8::Isolate::GetCurrent();
util::Promise promise(isolate);
util::Promise<void*> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
content::BrowserContext::GetDefaultStoragePartition(browser_context_.get())
->GetNetworkContext()
->ClearHttpAuthCache(base::Time(),
base::BindOnce(util::Promise::ResolveEmptyPromise,
std::move(promise)));
->ClearHttpAuthCache(
base::Time(),
base::BindOnce(util::Promise<void*>::ResolveEmptyPromise,
std::move(promise)));
return handle;
}
@ -495,7 +498,7 @@ std::string Session::GetUserAgent() {
v8::Local<v8::Promise> Session::GetBlobData(v8::Isolate* isolate,
const std::string& uuid) {
util::Promise promise(isolate);
util::Promise<v8::Local<v8::Value>> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
AtomBlobReader* blob_reader = browser_context()->GetBlobReader();

16
shell/browser/api/atom_api_system_preferences_mac.mm
View file

@ -451,7 +451,7 @@ bool SystemPreferences::CanPromptTouchID() {
v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
v8::Isolate* isolate,
const std::string& reason) {
util::Promise promise(isolate);
util::Promise<void*> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (@available(macOS 10.12.2, *)) {
@ -468,7 +468,7 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
scoped_refptr<base::SequencedTaskRunner> runner =
base::SequencedTaskRunnerHandle::Get();
__block util::Promise p = std::move(promise);
__block util::Promise<void*> p = std::move(promise);
[context
evaluateAccessControl:access_control
operation:LAAccessControlOperationUseKeySign
@ -479,14 +479,14 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
[error.localizedDescription UTF8String]);
runner->PostTask(
FROM_HERE,
base::BindOnce(util::Promise::RejectPromise,
std::move(p),
std::move(err_msg)));
base::BindOnce(
util::Promise<void*>::RejectPromise,
std::move(p), std::move(err_msg)));
} else {
runner->PostTask(
FROM_HERE,
base::BindOnce(
util::Promise::ResolveEmptyPromise,
util::Promise<void*>::ResolveEmptyPromise,
std::move(p)));
}
}];
@ -607,12 +607,12 @@ std::string SystemPreferences::GetMediaAccessStatus(
v8::Local<v8::Promise> SystemPreferences::AskForMediaAccess(
v8::Isolate* isolate,
const std::string& media_type) {
util::Promise promise(isolate);
util::Promise<bool> promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (auto type = ParseMediaType(media_type)) {
if (@available(macOS 10.14, *)) {
__block util::Promise p = std::move(promise);
__block util::Promise<bool> p = std::move(promise);
[AVCaptureDevice requestAccessForMediaType:type
completionHandler:^(BOOL granted) {
dispatch_async(dispatch_get_main_queue(), ^{

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

@ -302,7 +302,8 @@ namespace api {
namespace {
// Called when CapturePage is done.
void OnCapturePageDone(util::Promise promise, const SkBitmap& bitmap) {
void OnCapturePageDone(util::Promise<gfx::Image> promise,
const SkBitmap& bitmap) {
// Hack to enable transparency in captured image
promise.Resolve(gfx::Image::CreateFrom1xBitmap(bitmap));
}
@ -1417,7 +1418,7 @@ std::string WebContents::GetUserAgent() {
v8::Local<v8::Promise> WebContents::SavePage(
const base::FilePath& full_file_path,
const content::SavePageType& save_type) {
util::Promise promise(isolate());
util::Promise<void*> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto* handler = new SavePageHandler(web_contents(), std::move(promise));
@ -1749,7 +1750,7 @@ std::vector<printing::PrinterBasicInfo> WebContents::GetPrinterList() {
v8::Local<v8::Promise> WebContents::PrintToPDF(
const base::DictionaryValue& settings) {
util::Promise promise(isolate());
util::Promise<v8::Local<v8::Value>> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
PrintPreviewMessageHandler::FromWebContents(web_contents())
->PrintToPDF(settings, std::move(promise));
@ -2052,7 +2053,7 @@ void WebContents::StartDrag(const mate::Dictionary& item,
v8::Local<v8::Promise> WebContents::CapturePage(mate::Arguments* args) {
gfx::Rect rect;
util::Promise promise(isolate());
util::Promise<gfx::Image> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
// get rect arguments if they exist
@ -2319,7 +2320,7 @@ void WebContents::GrantOriginAccess(const GURL& url) {
v8::Local<v8::Promise> WebContents::TakeHeapSnapshot(
const base::FilePath& file_path) {
util::Promise promise(isolate());
util::Promise<void*> promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
base::ThreadRestrictions::ScopedAllowIO allow_io;
@ -2346,8 +2347,8 @@ v8::Local<v8::Promise> WebContents::TakeHeapSnapshot(
(*raw_ptr)->TakeHeapSnapshot(
mojo::WrapPlatformFile(file.TakePlatformFile()),
base::BindOnce(
[](mojom::ElectronRendererAssociatedPtr* ep, util::Promise promise,
bool success) {
[](mojom::ElectronRendererAssociatedPtr* ep,
util::Promise<void*> promise, bool success) {
if (success) {
promise.Resolve();
} else {

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

@ -61,7 +61,8 @@ void GPUInfoManager::OnGpuInfoUpdate() {
}
// Should be posted to the task runner
void GPUInfoManager::CompleteInfoFetcher(util::Promise promise) {
void GPUInfoManager::CompleteInfoFetcher(
util::Promise<base::DictionaryValue> promise) {
complete_info_promise_set_.emplace_back(std::move(promise));
if (NeedsCompleteGpuInfoCollection()) {
@ -71,7 +72,8 @@ void GPUInfoManager::CompleteInfoFetcher(util::Promise promise) {
}
}
void GPUInfoManager::FetchCompleteInfo(util::Promise promise) {
void GPUInfoManager::FetchCompleteInfo(
util::Promise<base::DictionaryValue> promise) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&GPUInfoManager::CompleteInfoFetcher,
base::Unretained(this), std::move(promise)));
@ -79,7 +81,8 @@ void GPUInfoManager::FetchCompleteInfo(util::Promise promise) {
// 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(util::Promise promise) {
void GPUInfoManager::FetchBasicInfo(
util::Promise<base::DictionaryValue> promise) {
gpu::GPUInfo gpu_info;
CollectBasicGraphicsInfo(&gpu_info);
promise.Resolve(*EnumerateGPUInfo(gpu_info));

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

@ -25,8 +25,8 @@ class GPUInfoManager : public content::GpuDataManagerObserver {
GPUInfoManager();
~GPUInfoManager() override;
bool NeedsCompleteGpuInfoCollection() const;
void FetchCompleteInfo(util::Promise promise);
void FetchBasicInfo(util::Promise promise);
void FetchCompleteInfo(util::Promise<base::DictionaryValue> promise);
void FetchBasicInfo(util::Promise<base::DictionaryValue> promise);
void OnGpuInfoUpdate() override;
private:
@ -34,12 +34,12 @@ class GPUInfoManager : public content::GpuDataManagerObserver {
gpu::GPUInfo gpu_info) const;
// These should be posted to the task queue
void CompleteInfoFetcher(util::Promise promise);
void CompleteInfoFetcher(util::Promise<base::DictionaryValue> promise);
void ProcessCompleteInfo();
// This set maintains all the promises that should be fulfilled
// once we have the complete information data
std::vector<util::Promise> complete_info_promise_set_;
std::vector<util::Promise<base::DictionaryValue>> complete_info_promise_set_;
content::GpuDataManager* gpu_data_manager_;
DISALLOW_COPY_AND_ASSIGN(GPUInfoManager);

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

@ -17,7 +17,7 @@ namespace electron {
namespace api {
SavePageHandler::SavePageHandler(content::WebContents* web_contents,
util::Promise promise)
util::Promise<void*> promise)
: web_contents_(web_contents), promise_(std::move(promise)) {}
SavePageHandler::~SavePageHandler() {}

4
shell/browser/api/save_page_handler.h
View file

@ -30,7 +30,7 @@ class SavePageHandler : public content::DownloadManager::Observer,
public download::DownloadItem::Observer {
public:
SavePageHandler(content::WebContents* web_contents,
electron::util::Promise promise);
electron::util::Promise<void*> promise);
~SavePageHandler() override;
bool Handle(const base::FilePath& full_path,
@ -47,7 +47,7 @@ class SavePageHandler : public content::DownloadManager::Observer,
void OnDownloadUpdated(download::DownloadItem* item) override;
content::WebContents* web_contents_; // weak
electron::util::Promise promise_;
electron::util::Promise<void*> promise_;
};
} // namespace api