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

chore: make util::Promise a move-only type (#17071)

Browse source
This commit is contained in:
Cheng Zhao 2019-02-21 12:32:44 +00:00 • committed by GitHub
parent a40d826b11
commit 32a4de4a68
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
29 changed files with 325 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

41
atom/browser/api/atom_api_app.cc
View file

@ -533,12 +533,11 @@ int ImportIntoCertStore(CertificateManagerModel* model,
}
#endif
void OnIconDataAvailable(scoped_refptr<util::Promise> promise,
gfx::Image* icon) {
void OnIconDataAvailable(util::Promise promise, gfx::Image* icon) {
if (icon && !icon->IsEmpty()) {
promise->Resolve(*icon);
promise.Resolve(*icon);
} else {
promise->RejectWithErrorMessage("Failed to get file icon.");
promise.RejectWithErrorMessage("Failed to get file icon.");
}
}
@ -1126,7 +1125,8 @@ JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
v8::Local<v8::Promise> App::GetFileIcon(const base::FilePath& path,
mate::Arguments* args) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
base::FilePath normalized_path = path.NormalizePathSeparators();
IconLoader::IconSize icon_size;
@ -1143,13 +1143,14 @@ v8::Local<v8::Promise> App::GetFileIcon(const base::FilePath& path,
gfx::Image* icon =
icon_manager->LookupIconFromFilepath(normalized_path, icon_size);
if (icon) {
promise->Resolve(*icon);
promise.Resolve(*icon);
} else {
icon_manager->LoadIcon(normalized_path, icon_size,
base::Bind(&OnIconDataAvailable, promise),
&cancelable_task_tracker_);
icon_manager->LoadIcon(
normalized_path, icon_size,
base::BindOnce(&OnIconDataAvailable, std::move(promise)),
&cancelable_task_tracker_);
}
return promise->GetHandle();
return handle;
}
std::vector<mate::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
@ -1198,30 +1199,30 @@ 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();
scoped_refptr<util::Promise> promise = new util::Promise(isolate);
util::Promise promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (info_type != "basic" && info_type != "complete") {
promise->RejectWithErrorMessage(
promise.RejectWithErrorMessage(
"Invalid info type. Use 'basic' or 'complete'");
return promise->GetHandle();
return handle;
}
std::string reason;
if (!gpu_data_manager->GpuAccessAllowed(&reason)) {
promise->RejectWithErrorMessage("GPU access not allowed. Reason: " +
reason);
return promise->GetHandle();
promise.RejectWithErrorMessage("GPU access not allowed. Reason: " + reason);
return handle;
}
auto* const info_mgr = GPUInfoManager::GetInstance();
if (info_type == "complete") {
#if defined(OS_WIN) || defined(OS_MACOSX)
info_mgr->FetchCompleteInfo(promise);
info_mgr->FetchCompleteInfo(std::move(promise));
#else
info_mgr->FetchBasicInfo(promise);
info_mgr->FetchBasicInfo(std::move(promise));
#endif
} else /* (info_type == "basic") */ {
info_mgr->FetchBasicInfo(promise);
info_mgr->FetchBasicInfo(std::move(promise));
}
return promise->GetHandle();
return handle;
}
static void RemoveNoSandboxSwitch(base::CommandLine* command_line) {

71
atom/browser/api/atom_api_content_tracing.cc
View file

@ -66,74 +66,73 @@ scoped_refptr<TracingController::TraceDataEndpoint> GetTraceDataEndpoint(
result_file_path, base::Bind(callback, result_file_path));
}
void OnRecordingStopped(scoped_refptr<atom::util::Promise> promise,
void OnRecordingStopped(const atom::util::CopyablePromise& promise,
const base::FilePath& path) {
promise->Resolve(path);
promise.GetPromise().Resolve(path);
}
v8::Local<v8::Promise> StopRecording(v8::Isolate* isolate,
const base::FilePath& path) {
scoped_refptr<atom::util::Promise> promise = new atom::util::Promise(isolate);
atom::util::Promise promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
TracingController::GetInstance()->StopTracing(
GetTraceDataEndpoint(path, base::Bind(&OnRecordingStopped, promise)));
return promise->GetHandle();
// TODO(zcbenz): Remove the use of CopyablePromise when the
// CreateFileEndpoint API accepts OnceCallback.
TracingController::GetInstance()->StopTracing(GetTraceDataEndpoint(
path,
base::Bind(&OnRecordingStopped, atom::util::CopyablePromise(promise))));
return handle;
}
void OnCategoriesAvailable(scoped_refptr<atom::util::Promise> promise,
void OnCategoriesAvailable(atom::util::Promise promise,
const std::set<std::string>& categories) {
promise->Resolve(categories);
promise.Resolve(categories);
}
v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
scoped_refptr<atom::util::Promise> promise = new atom::util::Promise(isolate);
bool success = TracingController::GetInstance()->GetCategories(
base::BindOnce(&OnCategoriesAvailable, promise));
atom::util::Promise promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (!success)
promise->RejectWithErrorMessage("Could not get categories.");
return promise->GetHandle();
// Note: This method always succeeds.
TracingController::GetInstance()->GetCategories(
base::BindOnce(&OnCategoriesAvailable, std::move(promise)));
return handle;
}
void OnTracingStarted(scoped_refptr<atom::util::Promise> promise) {
promise->Resolve();
void OnTracingStarted(atom::util::Promise promise) {
promise.Resolve();
}
v8::Local<v8::Promise> StartTracing(
v8::Isolate* isolate,
const base::trace_event::TraceConfig& trace_config) {
scoped_refptr<atom::util::Promise> promise = new atom::util::Promise(isolate);
atom::util::Promise promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
bool success = TracingController::GetInstance()->StartTracing(
trace_config, base::BindOnce(&OnTracingStarted, promise));
if (!success)
promise->RejectWithErrorMessage("Could not start tracing");
return promise->GetHandle();
// Note: This method always succeeds.
TracingController::GetInstance()->StartTracing(
trace_config, base::BindOnce(&OnTracingStarted, std::move(promise)));
return handle;
}
void OnTraceBufferUsageAvailable(scoped_refptr<atom::util::Promise> promise,
void OnTraceBufferUsageAvailable(atom::util::Promise promise,
float percent_full,
size_t approximate_count) {
mate::Dictionary dict = mate::Dictionary::CreateEmpty(promise->isolate());
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.GetHandle());
}
v8::Local<v8::Promise> GetTraceBufferUsage(v8::Isolate* isolate) {
scoped_refptr<atom::util::Promise> promise = new atom::util::Promise(isolate);
bool success = TracingController::GetInstance()->GetTraceBufferUsage(
base::BindOnce(&OnTraceBufferUsageAvailable, promise));
atom::util::Promise promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (!success)
promise->RejectWithErrorMessage("Could not get trace buffer usage.");
return promise->GetHandle();
// Note: This method always succeeds.
TracingController::GetInstance()->GetTraceBufferUsage(
base::BindOnce(&OnTraceBufferUsageAvailable, std::move(promise)));
return handle;
}
void Initialize(v8::Local<v8::Object> exports,

79
atom/browser/api/atom_api_cookies.cc
View file

@ -136,29 +136,29 @@ inline net::CookieStore* GetCookieStore(
return getter->GetURLRequestContext()->cookie_store();
}
void ResolvePromiseWithCookies(scoped_refptr<util::Promise> promise,
net::CookieList cookieList) {
promise->Resolve(cookieList);
void ResolvePromiseWithCookies(util::Promise promise,
const net::CookieList& cookie_list) {
promise.Resolve(cookie_list);
}
void ResolvePromise(scoped_refptr<util::Promise> promise) {
promise->Resolve();
void ResolvePromise(util::Promise promise) {
promise.Resolve();
}
// Resolve |promise| in UI thread.
void ResolvePromiseInUI(scoped_refptr<util::Promise> promise) {
void ResolvePromiseInUI(util::Promise promise) {
base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI},
base::BindOnce(ResolvePromise, std::move(promise)));
}
// Run |callback| on UI thread.
void RunCallbackInUI(const base::Closure& callback) {
base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, callback);
void RunCallbackInUI(base::OnceClosure callback) {
base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI}, std::move(callback));
}
// Remove cookies from |list| not matching |filter|, and pass it to |callback|.
void FilterCookies(std::unique_ptr<base::DictionaryValue> filter,
scoped_refptr<util::Promise> promise,
util::Promise promise,
const net::CookieList& list) {
net::CookieList result;
for (const auto& cookie : list) {
@ -174,50 +174,50 @@ void FilterCookies(std::unique_ptr<base::DictionaryValue> filter,
// Receives cookies matching |filter| in IO thread.
void GetCookiesOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
std::unique_ptr<base::DictionaryValue> filter,
scoped_refptr<util::Promise> promise) {
util::Promise promise) {
std::string url;
filter->GetString("url", &url);
auto filtered_callback =
base::Bind(FilterCookies, base::Passed(&filter), std::move(promise));
base::BindOnce(FilterCookies, std::move(filter), std::move(promise));
// Empty url will match all url cookies.
if (url.empty())
GetCookieStore(getter)->GetAllCookiesAsync(filtered_callback);
GetCookieStore(getter)->GetAllCookiesAsync(std::move(filtered_callback));
else
GetCookieStore(getter)->GetAllCookiesForURLAsync(GURL(url),
filtered_callback);
GetCookieStore(getter)->GetAllCookiesForURLAsync(
GURL(url), std::move(filtered_callback));
}
// Removes cookie with |url| and |name| in IO thread.
void RemoveCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
const GURL& url,
const std::string& name,
scoped_refptr<util::Promise> promise) {
util::Promise promise) {
GetCookieStore(getter)->DeleteCookieAsync(
url, name, base::BindOnce(ResolvePromiseInUI, std::move(promise)));
}
// Resolves/rejects the |promise| in UI thread.
void SettlePromiseInUI(scoped_refptr<util::Promise> promise,
const std::string& errmsg) {
void SettlePromiseInUI(util::Promise promise, const std::string& errmsg) {
if (errmsg.empty()) {
promise->Resolve();
promise.Resolve();
} else {
promise->RejectWithErrorMessage(errmsg);
promise.RejectWithErrorMessage(errmsg);
}
}
// Callback of SetCookie.
void OnSetCookie(scoped_refptr<util::Promise> promise, bool success) {
void OnSetCookie(util::Promise promise, bool success) {
const std::string errmsg = success ? "" : "Setting cookie failed";
RunCallbackInUI(base::Bind(SettlePromiseInUI, std::move(promise), errmsg));
RunCallbackInUI(
base::BindOnce(SettlePromiseInUI, std::move(promise), errmsg));
}
// Flushes cookie store in IO thread.
void FlushCookieStoreOnIOThread(
scoped_refptr<net::URLRequestContextGetter> getter,
scoped_refptr<util::Promise> promise) {
util::Promise promise) {
GetCookieStore(getter)->FlushStore(
base::BindOnce(ResolvePromiseInUI, std::move(promise)));
}
@ -225,7 +225,7 @@ void FlushCookieStoreOnIOThread(
// Sets cookie with |details| in IO thread.
void SetCookieOnIO(scoped_refptr<net::URLRequestContextGetter> getter,
std::unique_ptr<base::DictionaryValue> details,
scoped_refptr<util::Promise> promise) {
util::Promise promise) {
std::string url, name, value, domain, path;
bool secure = false;
bool http_only = false;
@ -297,7 +297,8 @@ Cookies::Cookies(v8::Isolate* isolate, AtomBrowserContext* browser_context)
Cookies::~Cookies() {}
v8::Local<v8::Promise> Cookies::Get(const base::DictionaryValue& filter) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto copy = base::DictionaryValue::From(
base::Value::ToUniquePtrValue(filter.Clone()));
@ -305,26 +306,28 @@ v8::Local<v8::Promise> Cookies::Get(const base::DictionaryValue& filter) {
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO},
base::BindOnce(GetCookiesOnIO, base::RetainedRef(getter), std::move(copy),
promise));
std::move(promise)));
return promise->GetHandle();
return handle;
}
v8::Local<v8::Promise> Cookies::Remove(const GURL& url,
const std::string& name) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto* getter = browser_context_->GetRequestContext();
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO},
base::BindOnce(RemoveCookieOnIO, base::RetainedRef(getter), url, name,
promise));
std::move(promise)));
return promise->GetHandle();
return handle;
}
v8::Local<v8::Promise> Cookies::Set(const base::DictionaryValue& details) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto copy = base::DictionaryValue::From(
base::Value::ToUniquePtrValue(details.Clone()));
@ -332,20 +335,22 @@ v8::Local<v8::Promise> Cookies::Set(const base::DictionaryValue& details) {
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO},
base::BindOnce(SetCookieOnIO, base::RetainedRef(getter), std::move(copy),
promise));
std::move(promise)));
return promise->GetHandle();
return handle;
}
v8::Local<v8::Promise> Cookies::FlushStore() {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto* getter = browser_context_->GetRequestContext();
base::PostTaskWithTraits(FROM_HERE, {BrowserThread::IO},
base::BindOnce(FlushCookieStoreOnIOThread,
base::RetainedRef(getter), promise));
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO},
base::BindOnce(FlushCookieStoreOnIOThread, base::RetainedRef(getter),
std::move(promise)));
return promise->GetHandle();
return handle;
}
void Cookies::OnCookieChanged(const CookieDetails* details) {

25
atom/browser/api/atom_api_debugger.cc
View file

@ -65,21 +65,21 @@ void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
if (it == pending_requests_.end())
return;
scoped_refptr<atom::util::Promise> promise = it->second;
atom::util::Promise promise = std::move(it->second);
pending_requests_.erase(it);
base::DictionaryValue* error = nullptr;
if (dict->GetDictionary("error", &error)) {
std::string message;
error->GetString("message", &message);
promise->RejectWithErrorMessage(message);
promise.RejectWithErrorMessage(message);
} else {
base::DictionaryValue* result_body = nullptr;
base::DictionaryValue result;
if (dict->GetDictionary("result", &result_body)) {
result.Swap(result_body);
}
promise->Resolve(result);
promise.Resolve(result);
}
}
}
@ -129,17 +129,18 @@ void Debugger::Detach() {
}
v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
atom::util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
if (!agent_host_) {
promise->RejectWithErrorMessage("No target available");
return promise->GetHandle();
promise.RejectWithErrorMessage("No target available");
return handle;
}
std::string method;
if (!args->GetNext(&method)) {
promise->RejectWithErrorMessage("Invalid method");
return promise->GetHandle();
promise.RejectWithErrorMessage("Invalid method");
return handle;
}
base::DictionaryValue command_params;
@ -147,7 +148,7 @@ v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
base::DictionaryValue request;
int request_id = ++previous_request_id_;
pending_requests_[request_id] = promise;
pending_requests_.emplace(request_id, std::move(promise));
request.SetInteger("id", request_id);
request.SetString("method", method);
if (!command_params.empty())
@ -158,12 +159,12 @@ v8::Local<v8::Promise> Debugger::SendCommand(mate::Arguments* args) {
base::JSONWriter::Write(request, &json_args);
agent_host_->DispatchProtocolMessage(this, json_args);
return promise->GetHandle();
return handle;
}
void Debugger::ClearPendingRequests() {
for (const auto& it : pending_requests_)
it.second->RejectWithErrorMessage("target closed while handling command");
for (auto& it : pending_requests_)
it.second.RejectWithErrorMessage("target closed while handling command");
}
// static

2
atom/browser/api/atom_api_debugger.h
View file

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

19
atom/browser/api/atom_api_net_log.cc
View file

@ -22,9 +22,9 @@
namespace {
void OnGetFilePathToCompletedLog(scoped_refptr<atom::util::Promise> promise,
void OnGetFilePathToCompletedLog(const atom::util::CopyablePromise& promise,
const base::FilePath& file_path) {
promise->Resolve(file_path);
promise.GetPromise().Resolve(file_path);
}
} // namespace
@ -97,16 +97,17 @@ std::string NetLog::GetCurrentlyLoggingPath() const {
}
v8::Local<v8::Promise> NetLog::StopLogging(mate::Arguments* args) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
if (IsCurrentlyLogging()) {
stop_callback_queue_.emplace_back(promise);
stop_callback_queue_.emplace_back(std::move(promise));
net_log_writer_->StopNetLog(nullptr);
} else {
promise->Resolve(base::FilePath());
promise.Resolve(base::FilePath());
}
return promise->GetHandle();
return handle;
}
void NetLog::OnNewState(const base::DictionaryValue& state) {
@ -117,8 +118,10 @@ void NetLog::OnNewState(const base::DictionaryValue& state) {
if (GetLoggingState() == "NOT_LOGGING") {
for (auto& promise : stop_callback_queue_) {
net_log_writer_->GetFilePathToCompletedLog(
base::Bind(&OnGetFilePathToCompletedLog, promise));
// TODO(zcbenz): Remove the use of CopyablePromise when the
// GetFilePathToCompletedLog API accepts OnceCallback.
net_log_writer_->GetFilePathToCompletedLog(base::Bind(
&OnGetFilePathToCompletedLog, util::CopyablePromise(promise)));
}
stop_callback_queue_.clear();
}

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

@ -47,7 +47,7 @@ class NetLog : public mate::TrackableObject<NetLog>,
private:
AtomBrowserContext* browser_context_;
net_log::NetExportFileWriter* net_log_writer_;
std::list<scoped_refptr<atom::util::Promise>> stop_callback_queue_;
std::list<atom::util::Promise> stop_callback_queue_;
std::unique_ptr<base::DictionaryValue> net_log_state_;
DISALLOW_COPY_AND_ASSIGN(NetLog);

13
atom/browser/api/atom_api_protocol.cc
View file

@ -177,21 +177,22 @@ bool IsProtocolHandledInIO(
return is_handled;
}
void PromiseCallback(scoped_refptr<util::Promise> promise, bool handled) {
promise->Resolve(handled);
void PromiseCallback(util::Promise promise, bool handled) {
promise.Resolve(handled);
}
v8::Local<v8::Promise> Protocol::IsProtocolHandled(const std::string& scheme) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
auto* getter = static_cast<URLRequestContextGetter*>(
browser_context_->GetRequestContext());
base::PostTaskWithTraitsAndReplyWithResult(
FROM_HERE, {content::BrowserThread::IO},
base::Bind(&IsProtocolHandledInIO, base::RetainedRef(getter), scheme),
base::Bind(&PromiseCallback, promise));
base::BindOnce(&IsProtocolHandledInIO, base::RetainedRef(getter), scheme),
base::BindOnce(&PromiseCallback, std::move(promise)));
return promise->GetHandle();
return handle;
}
void Protocol::UninterceptProtocol(const std::string& scheme,

38
atom/browser/api/atom_api_system_preferences_mac.mm
View file

@ -457,19 +457,20 @@ bool SystemPreferences::CanPromptTouchID() {
return false;
}
void OnTouchIDCompleted(scoped_refptr<util::Promise> promise) {
promise->Resolve();
void OnTouchIDCompleted(util::Promise promise) {
promise.Resolve();
}
void OnTouchIDFailed(scoped_refptr<util::Promise> promise,
const std::string& reason) {
promise->RejectWithErrorMessage(reason);
void OnTouchIDFailed(util::Promise promise, const std::string& reason) {
promise.RejectWithErrorMessage(reason);
}
v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
v8::Isolate* isolate,
const std::string& reason) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate);
util::Promise promise(isolate);
v8::Local<v8::Promise> handle = promise.GetHandle();
if (@available(macOS 10.12.2, *)) {
base::scoped_nsobject<LAContext> context([[LAContext alloc] init]);
base::ScopedCFTypeRef<SecAccessControlRef> access_control =
@ -484,6 +485,7 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
scoped_refptr<base::SequencedTaskRunner> runner =
base::SequencedTaskRunnerHandle::Get();
__block util::Promise p = std::move(promise);
[context
evaluateAccessControl:access_control
operation:LAAccessControlOperationUseKeySign
@ -493,20 +495,20 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
runner->PostTask(
FROM_HERE,
base::BindOnce(
&OnTouchIDFailed, promise,
&OnTouchIDFailed, std::move(p),
std::string([error.localizedDescription
UTF8String])));
} else {
runner->PostTask(
FROM_HERE,
base::BindOnce(&OnTouchIDCompleted, promise));
runner->PostTask(FROM_HERE,
base::BindOnce(&OnTouchIDCompleted,
std::move(p)));
}
}];
} else {
promise->RejectWithErrorMessage(
promise.RejectWithErrorMessage(
"This API is not available on macOS versions older than 10.12.2");
}
return promise->GetHandle();
return handle;
}
// static
@ -625,25 +627,27 @@ std::string SystemPreferences::GetMediaAccessStatus(
v8::Local<v8::Promise> SystemPreferences::AskForMediaAccess(
v8::Isolate* isolate,
const std::string& media_type) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate);
util::Promise 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);
[AVCaptureDevice requestAccessForMediaType:type
completionHandler:^(BOOL granted) {
dispatch_async(dispatch_get_main_queue(), ^{
promise->Resolve(!!granted);
p.Resolve(!!granted);
});
}];
} else {
// access always allowed pre-10.14 Mojave
promise->Resolve(true);
promise.Resolve(true);
}
} else {
promise->RejectWithErrorMessage("Invalid media type");
promise.RejectWithErrorMessage("Invalid media type");
}
return promise->GetHandle();
return handle;
}
void SystemPreferences::RemoveUserDefault(const std::string& name) {

35
atom/browser/api/atom_api_web_contents.cc
View file

@ -241,12 +241,11 @@ namespace api {
namespace {
// Called when CapturePage is done.
void OnCapturePageDone(scoped_refptr<util::Promise> promise,
const SkBitmap& bitmap) {
void OnCapturePageDone(util::Promise promise, const SkBitmap& bitmap) {
// Hack to enable transparency in captured image
// TODO(nitsakh) Remove hack once fixed in chromium
const_cast<SkBitmap&>(bitmap).setAlphaType(kPremul_SkAlphaType);
promise->Resolve(gfx::Image::CreateFrom1xBitmap(bitmap));
promise.Resolve(gfx::Image::CreateFrom1xBitmap(bitmap));
}
} // namespace
@ -1302,14 +1301,12 @@ std::string WebContents::GetUserAgent() {
v8::Local<v8::Promise> WebContents::SavePage(
const base::FilePath& full_file_path,
const content::SavePageType& save_type) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
auto* handler = new SavePageHandler(web_contents(), promise);
util::Promise promise(isolate());
v8::Local<v8::Promise> ret = promise.GetHandle();
const bool saveStarted = handler->Handle(full_file_path, save_type);
if (!saveStarted)
promise->RejectWithErrorMessage("Failed to save the page");
return promise->GetHandle();
auto* handler = new SavePageHandler(web_contents(), std::move(promise));
handler->Handle(full_file_path, save_type);
return ret;
}
void WebContents::OpenDevTools(mate::Arguments* args) {
@ -1506,10 +1503,11 @@ std::vector<printing::PrinterBasicInfo> WebContents::GetPrinterList() {
v8::Local<v8::Promise> WebContents::PrintToPDF(
const base::DictionaryValue& settings) {
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
PrintPreviewMessageHandler::FromWebContents(web_contents())
->PrintToPDF(settings, promise);
return promise->GetHandle();
->PrintToPDF(settings, std::move(promise));
return handle;
}
#endif
@ -1780,15 +1778,16 @@ void WebContents::StartDrag(const mate::Dictionary& item,
v8::Local<v8::Promise> WebContents::CapturePage(mate::Arguments* args) {
gfx::Rect rect;
scoped_refptr<util::Promise> promise = new util::Promise(isolate());
util::Promise promise(isolate());
v8::Local<v8::Promise> handle = promise.GetHandle();
// get rect arguments if they exist
args->GetNext(&rect);
auto* const view = web_contents()->GetRenderWidgetHostView();
if (!view) {
promise->Resolve(gfx::Image());
return promise->GetHandle();
promise.Resolve(gfx::Image());
return handle;
}
// Capture full page if user doesn't specify a |rect|.
@ -1807,8 +1806,8 @@ v8::Local<v8::Promise> WebContents::CapturePage(mate::Arguments* args) {
bitmap_size = gfx::ScaleToCeiledSize(view_size, scale);
view->CopyFromSurface(gfx::Rect(rect.origin(), view_size), bitmap_size,
base::BindOnce(&OnCapturePageDone, promise));
return promise->GetHandle();
base::BindOnce(&OnCapturePageDone, std::move(promise)));
return handle;
}
void WebContents::OnCursorChange(const content::WebCursor& cursor) {

19
atom/browser/api/gpuinfo_manager.cc
View file

@ -3,6 +3,9 @@
// found in the LICENSE file.
#include "atom/browser/api/gpuinfo_manager.h"
#include <utility>
#include "atom/browser/api/gpu_info_enumerator.h"
#include "base/memory/singleton.h"
#include "base/threading/thread_task_runner_handle.h"
@ -42,8 +45,8 @@ void GPUInfoManager::ProcessCompleteInfo() {
const auto result = EnumerateGPUInfo(gpu_data_manager_->GetGPUInfo());
// We have received the complete information, resolve all promises that
// were waiting for this info.
for (const auto& promise : complete_info_promise_set_) {
promise->Resolve(*result);
for (auto& promise : complete_info_promise_set_) {
promise.Resolve(*result);
}
complete_info_promise_set_.clear();
}
@ -58,8 +61,8 @@ void GPUInfoManager::OnGpuInfoUpdate() {
}
// Should be posted to the task runner
void GPUInfoManager::CompleteInfoFetcher(scoped_refptr<util::Promise> promise) {
complete_info_promise_set_.push_back(promise);
void GPUInfoManager::CompleteInfoFetcher(util::Promise promise) {
complete_info_promise_set_.emplace_back(std::move(promise));
if (NeedsCompleteGpuInfoCollection()) {
gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
@ -68,18 +71,18 @@ void GPUInfoManager::CompleteInfoFetcher(scoped_refptr<util::Promise> promise) {
}
}
void GPUInfoManager::FetchCompleteInfo(scoped_refptr<util::Promise> promise) {
void GPUInfoManager::FetchCompleteInfo(util::Promise promise) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&GPUInfoManager::CompleteInfoFetcher,
base::Unretained(this), promise));
base::Unretained(this), std::move(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(scoped_refptr<util::Promise> promise) {
void GPUInfoManager::FetchBasicInfo(util::Promise promise) {
gpu::GPUInfo gpu_info;
CollectBasicGraphicsInfo(&gpu_info);
promise->Resolve(*EnumerateGPUInfo(gpu_info));
promise.Resolve(*EnumerateGPUInfo(gpu_info));
}
std::unique_ptr<base::DictionaryValue> GPUInfoManager::EnumerateGPUInfo(

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

@ -25,8 +25,8 @@ class GPUInfoManager : public content::GpuDataManagerObserver {
GPUInfoManager();
~GPUInfoManager() override;
bool NeedsCompleteGpuInfoCollection() const;
void FetchCompleteInfo(scoped_refptr<util::Promise> promise);
void FetchBasicInfo(scoped_refptr<util::Promise> promise);
void FetchCompleteInfo(util::Promise promise);
void FetchBasicInfo(util::Promise 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(scoped_refptr<util::Promise> promise);
void CompleteInfoFetcher(util::Promise promise);
void ProcessCompleteInfo();
// This set maintains all the promises that should be fulfilled
// once we have the complete information data
std::vector<scoped_refptr<util::Promise>> complete_info_promise_set_;
std::vector<util::Promise> complete_info_promise_set_;
content::GpuDataManager* gpu_data_manager_;
DISALLOW_COPY_AND_ASSIGN(GPUInfoManager);

13
atom/browser/api/save_page_handler.cc
View file

@ -5,6 +5,7 @@
#include "atom/browser/api/save_page_handler.h"
#include <string>
#include <utility>
#include "atom/browser/atom_browser_context.h"
#include "base/callback.h"
@ -16,8 +17,8 @@ namespace atom {
namespace api {
SavePageHandler::SavePageHandler(content::WebContents* web_contents,
scoped_refptr<atom::util::Promise> promise)
: web_contents_(web_contents), promise_(promise) {}
util::Promise promise)
: web_contents_(web_contents), promise_(std::move(promise)) {}
SavePageHandler::~SavePageHandler() {}
@ -43,17 +44,19 @@ bool SavePageHandler::Handle(const base::FilePath& full_path,
download_manager->RemoveObserver(this);
// If initialization fails which means fail to create |DownloadItem|, we need
// to delete the |SavePageHandler| instance to avoid memory-leak.
if (!result)
if (!result) {
promise_.RejectWithErrorMessage("Failed to save the page");
delete this;
}
return result;
}
void SavePageHandler::OnDownloadUpdated(download::DownloadItem* item) {
if (item->IsDone()) {
if (item->GetState() == download::DownloadItem::COMPLETE)
promise_->Resolve();
promise_.Resolve();
else
promise_->RejectWithErrorMessage("Failed to save the page.");
promise_.RejectWithErrorMessage("Failed to save the page.");
Destroy(item);
}
}

4
atom/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,
scoped_refptr<atom::util::Promise> promise);
atom::util::Promise 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
scoped_refptr<atom::util::Promise> promise_;
atom::util::Promise promise_;
};
} // namespace api