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

Convert Callbacks to OnceCallbacks in permissions APIs.

Browse source 
https://chromium-review.googlesource.com/c/chromium/src/+/1592356
This commit is contained in:
Jeremy Apthorp 2019-05-03 11:30:48 -07:00 committed by Nitish Sakhawalkar
parent e794260d89
commit 6c6555c13c
3 changed files with 56 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
atom/browser/api/atom_api_session.cc
View file

@ -452,14 +452,28 @@ void Session::SetCertVerifyProc(v8::Local<v8::Value> val,
void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val, void Session::SetPermissionRequestHandler(v8::Local<v8::Value> val,
mate::Arguments* args) { mate::Arguments* args) {
AtomPermissionManager::RequestHandler handler; using StatusCallback =
base::RepeatingCallback<void(blink::mojom::PermissionStatus)>;
using RequestHandler =
base::Callback<void(content::WebContents*, content::PermissionType,
StatusCallback, const base::DictionaryValue&)>;
RequestHandler handler;
if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &handler))) { if (!(val->IsNull() || mate::ConvertFromV8(args->isolate(), val, &handler))) {
args->ThrowError("Must pass null or function"); args->ThrowError("Must pass null or function");
return; return;
} }
auto* permission_manager = static_cast<AtomPermissionManager*>( auto* permission_manager = static_cast<AtomPermissionManager*>(
browser_context()->GetPermissionControllerDelegate()); browser_context()->GetPermissionControllerDelegate());
permission_manager->SetPermissionRequestHandler(handler); permission_manager->SetPermissionRequestHandler(base::BindRepeating(
[](const RequestHandler& handler, content::WebContents* web_contents,
content::PermissionType permission_type,
AtomPermissionManager::StatusCallback callback,
const base::DictionaryValue& details) {
handler.Run(web_contents, permission_type,
base::AdaptCallbackForRepeating(std::move(callback)),
details);
},
base::Passed(std::move(handler))));
} }
void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val, void Session::SetPermissionCheckHandler(v8::Local<v8::Value> val,

48
atom/browser/atom_permission_manager.cc
View file

@ -32,9 +32,9 @@ bool WebContentsDestroyed(int process_id) {
} }
void PermissionRequestResponseCallbackWrapper( void PermissionRequestResponseCallbackWrapper(
const AtomPermissionManager::StatusCallback& callback, AtomPermissionManager::StatusCallback callback,
const std::vector<blink::mojom::PermissionStatus>& vector) { const std::vector<blink::mojom::PermissionStatus>& vector) {
callback.Run(vector[0]); std::move(callback).Run(vector[0]);
} }
} // namespace } // namespace
@ -43,9 +43,9 @@ class AtomPermissionManager::PendingRequest {
public: public:
PendingRequest(content::RenderFrameHost* render_frame_host, PendingRequest(content::RenderFrameHost* render_frame_host,
const std::vector<content::PermissionType>& permissions, const std::vector<content::PermissionType>& permissions,
const StatusesCallback& callback) StatusesCallback callback)
: render_process_id_(render_frame_host->GetProcess()->GetID()), : render_process_id_(render_frame_host->GetProcess()->GetID()),
callback_(callback), callback_(std::move(callback)),
permissions_(permissions), permissions_(permissions),
results_(permissions.size(), blink::mojom::PermissionStatus::DENIED), results_(permissions.size(), blink::mojom::PermissionStatus::DENIED),
remaining_results_(permissions.size()) {} remaining_results_(permissions.size()) {}
@ -74,11 +74,15 @@ class AtomPermissionManager::PendingRequest {
bool IsComplete() const { return remaining_results_ == 0; } bool IsComplete() const { return remaining_results_ == 0; }
void RunCallback() const { callback_.Run(results_); } void RunCallback() {
if (!callback_.is_null()) {
std::move(callback_).Run(results_);
}
}
private: private:
int render_process_id_; int render_process_id_;
const StatusesCallback callback_; StatusesCallback callback_;
std::vector<content::PermissionType> permissions_; std::vector<content::PermissionType> permissions_;
std::vector<blink::mojom::PermissionStatus> results_; std::vector<blink::mojom::PermissionStatus> results_;
size_t remaining_results_; size_t remaining_results_;
@ -91,8 +95,8 @@ AtomPermissionManager::~AtomPermissionManager() {}
void AtomPermissionManager::SetPermissionRequestHandler( void AtomPermissionManager::SetPermissionRequestHandler(
const RequestHandler& handler) { const RequestHandler& handler) {
if (handler.is_null() && !pending_requests_.IsEmpty()) { if (handler.is_null() && !pending_requests_.IsEmpty()) {
for (PendingRequestsMap::const_iterator iter(&pending_requests_); for (PendingRequestsMap::iterator iter(&pending_requests_); !iter.IsAtEnd();
!iter.IsAtEnd(); iter.Advance()) { iter.Advance()) {
auto* request = iter.GetCurrentValue(); auto* request = iter.GetCurrentValue();
if (!WebContentsDestroyed(request->render_process_id())) if (!WebContentsDestroyed(request->render_process_id()))
request->RunCallback(); request->RunCallback();
@ -112,11 +116,10 @@ int AtomPermissionManager::RequestPermission(
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const base::Callback<void(blink::mojom::PermissionStatus)>& StatusCallback response_callback) {
response_callback) {
return RequestPermissionWithDetails(permission, render_frame_host, return RequestPermissionWithDetails(permission, render_frame_host,
requesting_origin, user_gesture, nullptr, requesting_origin, user_gesture, nullptr,
response_callback); std::move(response_callback));
} }
int AtomPermissionManager::RequestPermissionWithDetails( int AtomPermissionManager::RequestPermissionWithDetails(
@ -125,11 +128,12 @@ int AtomPermissionManager::RequestPermissionWithDetails(
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const base::DictionaryValue* details, const base::DictionaryValue* details,
const StatusCallback& response_callback) { StatusCallback response_callback) {
return RequestPermissionsWithDetails( return RequestPermissionsWithDetails(
std::vector<content::PermissionType>(1, permission), render_frame_host, std::vector<content::PermissionType>(1, permission), render_frame_host,
requesting_origin, user_gesture, details, requesting_origin, user_gesture, details,
base::Bind(&PermissionRequestResponseCallbackWrapper, response_callback)); base::BindOnce(PermissionRequestResponseCallbackWrapper,
std::move(response_callback)));
} }
int AtomPermissionManager::RequestPermissions( int AtomPermissionManager::RequestPermissions(
@ -137,10 +141,10 @@ int AtomPermissionManager::RequestPermissions(
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const StatusesCallback& response_callback) { StatusesCallback response_callback) {
return RequestPermissionsWithDetails(permissions, render_frame_host, return RequestPermissionsWithDetails(permissions, render_frame_host,
requesting_origin, user_gesture, nullptr, requesting_origin, user_gesture, nullptr,
response_callback); std::move(response_callback));
} }
int AtomPermissionManager::RequestPermissionsWithDetails( int AtomPermissionManager::RequestPermissionsWithDetails(
@ -149,9 +153,9 @@ int AtomPermissionManager::RequestPermissionsWithDetails(
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const base::DictionaryValue* details, const base::DictionaryValue* details,
const StatusesCallback& response_callback) { StatusesCallback response_callback) {
if (permissions.empty()) { if (permissions.empty()) {
response_callback.Run(std::vector<blink::mojom::PermissionStatus>()); std::move(response_callback).Run({});
return content::PermissionController::kNoPendingOperation; return content::PermissionController::kNoPendingOperation;
} }
@ -169,20 +173,20 @@ int AtomPermissionManager::RequestPermissionsWithDetails(
} }
statuses.push_back(blink::mojom::PermissionStatus::GRANTED); statuses.push_back(blink::mojom::PermissionStatus::GRANTED);
} }
response_callback.Run(statuses); std::move(response_callback).Run(statuses);
return content::PermissionController::kNoPendingOperation; return content::PermissionController::kNoPendingOperation;
} }
auto* web_contents = auto* web_contents =
content::WebContents::FromRenderFrameHost(render_frame_host); content::WebContents::FromRenderFrameHost(render_frame_host);
int request_id = pending_requests_.Add(std::make_unique<PendingRequest>( int request_id = pending_requests_.Add(std::make_unique<PendingRequest>(
render_frame_host, permissions, response_callback)); render_frame_host, permissions, std::move(response_callback)));
for (size_t i = 0; i < permissions.size(); ++i) { for (size_t i = 0; i < permissions.size(); ++i) {
auto permission = permissions[i]; auto permission = permissions[i];
const auto callback = const auto callback =
base::Bind(&AtomPermissionManager::OnPermissionResponse, base::BindRepeating(&AtomPermissionManager::OnPermissionResponse,
base::Unretained(this), request_id, i); base::Unretained(this), request_id, i);
if (details == nullptr) { if (details == nullptr) {
request_handler_.Run(web_contents, permission, callback, request_handler_.Run(web_contents, permission, callback,
base::DictionaryValue()); base::DictionaryValue());
@ -224,7 +228,7 @@ int AtomPermissionManager::SubscribePermissionStatusChange(
content::PermissionType permission, content::PermissionType permission,
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
const base::Callback<void(blink::mojom::PermissionStatus)>& callback) { base::RepeatingCallback<void(blink::mojom::PermissionStatus)> callback) {
return -1; return -1;
} }

32
atom/browser/atom_permission_manager.h
View file

@ -25,12 +25,13 @@ class AtomPermissionManager : public content::PermissionControllerDelegate {
AtomPermissionManager(); AtomPermissionManager();
~AtomPermissionManager() override; ~AtomPermissionManager() override;
using StatusCallback = base::Callback<void(blink::mojom::PermissionStatus)>; using StatusCallback =
using StatusesCallback = base::OnceCallback<void(blink::mojom::PermissionStatus)>;
base::Callback<void(const std::vector<blink::mojom::PermissionStatus>&)>; using StatusesCallback = base::OnceCallback<void(
const std::vector<blink::mojom::PermissionStatus>&)>;
using RequestHandler = base::Callback<void(content::WebContents*, using RequestHandler = base::Callback<void(content::WebContents*,
content::PermissionType, content::PermissionType,
const StatusCallback&, StatusCallback,
const base::DictionaryValue&)>; const base::DictionaryValue&)>;
using CheckHandler = base::Callback<bool(content::WebContents*, using CheckHandler = base::Callback<bool(content::WebContents*,
content::PermissionType, content::PermissionType,
@ -42,35 +43,30 @@ class AtomPermissionManager : public content::PermissionControllerDelegate {
void SetPermissionCheckHandler(const CheckHandler& handler); void SetPermissionCheckHandler(const CheckHandler& handler);
// content::PermissionControllerDelegate: // content::PermissionControllerDelegate:
int RequestPermission( int RequestPermission(content::PermissionType permission,
content::PermissionType permission, content::RenderFrameHost* render_frame_host,
content::RenderFrameHost* render_frame_host, const GURL& requesting_origin,
const GURL& requesting_origin, bool user_gesture,
bool user_gesture, StatusCallback callback) override;
const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
override;
int RequestPermissionWithDetails(content::PermissionType permission, int RequestPermissionWithDetails(content::PermissionType permission,
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const base::DictionaryValue* details, const base::DictionaryValue* details,
const StatusCallback& callback); StatusCallback callback);
int RequestPermissions( int RequestPermissions(
const std::vector<content::PermissionType>& permissions, const std::vector<content::PermissionType>& permissions,
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const base::Callback< StatusesCallback callback) override;
void(const std::vector<blink::mojom::PermissionStatus>&)>& callback)
override;
int RequestPermissionsWithDetails( int RequestPermissionsWithDetails(
const std::vector<content::PermissionType>& permissions, const std::vector<content::PermissionType>& permissions,
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
bool user_gesture, bool user_gesture,
const base::DictionaryValue* details, const base::DictionaryValue* details,
const base::Callback< StatusesCallback callback);
void(const std::vector<blink::mojom::PermissionStatus>&)>& callback);
blink::mojom::PermissionStatus GetPermissionStatusForFrame( blink::mojom::PermissionStatus GetPermissionStatusForFrame(
content::PermissionType permission, content::PermissionType permission,
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
@ -98,7 +94,7 @@ class AtomPermissionManager : public content::PermissionControllerDelegate {
content::PermissionType permission, content::PermissionType permission,
content::RenderFrameHost* render_frame_host, content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin, const GURL& requesting_origin,
const base::Callback<void(blink::mojom::PermissionStatus)>& callback) base::RepeatingCallback<void(blink::mojom::PermissionStatus)> callback)
override; override;
void UnsubscribePermissionStatusChange(int subscription_id) override; void UnsubscribePermissionStatusChange(int subscription_id) override;