From 18675cc6c16c9685d077311a9cc41ea6c395118b Mon Sep 17 00:00:00 2001 From: Kevin Sawicki Date: Mon, 19 Dec 2016 15:12:16 -0800 Subject: [PATCH] Implement RequestPermissions using request handler --- atom/browser/atom_permission_manager.cc | 160 ++++++++++++++++-------- atom/browser/atom_permission_manager.h | 20 ++- 2 files changed, 116 insertions(+), 64 deletions(-) diff --git a/atom/browser/atom_permission_manager.cc b/atom/browser/atom_permission_manager.cc index c0cc0d8483da..b22f4253237b 100644 --- a/atom/browser/atom_permission_manager.cc +++ b/atom/browser/atom_permission_manager.cc @@ -26,10 +26,52 @@ bool WebContentsDestroyed(int process_id) { return contents->IsBeingDestroyed(); } +void PermissionRequestResponseCallbackWrapper( + const AtomPermissionManager::StatusCallback& callback, + const std::vector& vector) { + callback.Run(vector[0]); +} + } // namespace -AtomPermissionManager::AtomPermissionManager() - : request_id_(0) { +class AtomPermissionManager::PendingRequest { + public: + PendingRequest(content::RenderFrameHost* render_frame_host, + const std::vector& permissions, + const StatusesCallback& callback) + : render_process_id_(render_frame_host->GetProcess()->GetID()), + callback_(callback), + results_(permissions.size(), blink::mojom::PermissionStatus::DENIED), + remaining_results_(permissions.size()) {} + + void SetPermissionStatus(int permission_id, + blink::mojom::PermissionStatus status) { + DCHECK(!IsComplete()); + + results_[permission_id] = status; + --remaining_results_; + } + + int render_process_id() const { + return render_process_id_; + } + + bool IsComplete() const { + return remaining_results_ == 0; + } + + void RunCallback() const { + callback_.Run(results_); + } + + private: + int render_process_id_; + const StatusesCallback callback_; + std::vector results_; + size_t remaining_results_; +}; + +AtomPermissionManager::AtomPermissionManager() { } AtomPermissionManager::~AtomPermissionManager() { @@ -37,12 +79,14 @@ AtomPermissionManager::~AtomPermissionManager() { void AtomPermissionManager::SetPermissionRequestHandler( const RequestHandler& handler) { - if (handler.is_null() && !pending_requests_.empty()) { - for (const auto& request : pending_requests_) { - if (!WebContentsDestroyed(request.second.render_process_id)) - request.second.callback.Run(blink::mojom::PermissionStatus::DENIED); + if (handler.is_null() && !pending_requests_.IsEmpty()) { + for (PendingRequestsMap::const_iterator iter(&pending_requests_); + !iter.IsAtEnd(); iter.Advance()) { + auto request = iter.GetCurrentValue(); + if (!WebContentsDestroyed(request->render_process_id())) + request->RunCallback(); } - pending_requests_.clear(); + pending_requests_.Clear(); } request_handler_ = handler; } @@ -52,30 +96,13 @@ int AtomPermissionManager::RequestPermission( content::RenderFrameHost* render_frame_host, const GURL& requesting_origin, bool user_gesture, - const ResponseCallback& response_callback) { - int process_id = render_frame_host->GetProcess()->GetID(); - - if (permission == content::PermissionType::MIDI_SYSEX) { - content::ChildProcessSecurityPolicy::GetInstance()-> - GrantSendMidiSysExMessage(process_id); - } - - if (!request_handler_.is_null()) { - auto web_contents = - content::WebContents::FromRenderFrameHost(render_frame_host); - ++request_id_; - auto callback = base::Bind(&AtomPermissionManager::OnPermissionResponse, - base::Unretained(this), - request_id_, - requesting_origin, - response_callback); - pending_requests_[request_id_] = { process_id, callback }; - request_handler_.Run(web_contents, permission, callback); - return request_id_; - } - - response_callback.Run(blink::mojom::PermissionStatus::GRANTED); - return kNoPendingOperation; + const StatusCallback& response_callback) { + return RequestPermissions( + std::vector(1, permission), + render_frame_host, + requesting_origin, + user_gesture, + base::Bind(&PermissionRequestResponseCallbackWrapper, response_callback)); } int AtomPermissionManager::RequestPermissions( @@ -83,41 +110,68 @@ int AtomPermissionManager::RequestPermissions( content::RenderFrameHost* render_frame_host, const GURL& requesting_origin, bool user_gesture, - const base::Callback&)>& callback) { - // FIXME(zcbenz): Just ignore multiple permissions request for now. - std::vector permissionStatuses; - for (auto permission : permissions) { + const StatusesCallback& response_callback) { + if (permissions.empty()) { + response_callback.Run(std::vector()); + return kNoPendingOperation; + } + + if (request_handler_.is_null()) { + std::vector statuses; + for (auto permission : permissions) { + if (permission == content::PermissionType::MIDI_SYSEX) { + content::ChildProcessSecurityPolicy::GetInstance()-> + GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID()); + } + statuses.push_back(blink::mojom::PermissionStatus::GRANTED); + } + response_callback.Run(statuses); + return kNoPendingOperation; + } + + auto web_contents = + content::WebContents::FromRenderFrameHost(render_frame_host); + int request_id = pending_requests_.Add(new PendingRequest( + render_frame_host, permissions, response_callback)); + + for (size_t i = 0; i < permissions.size(); ++i) { + auto permission = permissions[i]; if (permission == content::PermissionType::MIDI_SYSEX) { content::ChildProcessSecurityPolicy::GetInstance()-> GrantSendMidiSysExMessage(render_frame_host->GetProcess()->GetID()); } - permissionStatuses.push_back(blink::mojom::PermissionStatus::GRANTED); + const auto callback = + base::Bind(&AtomPermissionManager::OnPermissionResponse, + base::Unretained(this), request_id, i); + request_handler_.Run(web_contents, permission, callback); } - callback.Run(permissionStatuses); - return kNoPendingOperation; + + return request_id; } void AtomPermissionManager::OnPermissionResponse( int request_id, - const GURL& origin, - const ResponseCallback& callback, + int permission_id, blink::mojom::PermissionStatus status) { - auto request = pending_requests_.find(request_id); - if (request != pending_requests_.end()) { - if (!WebContentsDestroyed(request->second.render_process_id)) - callback.Run(status); - pending_requests_.erase(request); + auto pending_request = pending_requests_.Lookup(request_id); + if (!pending_request) + return; + + pending_request->SetPermissionStatus(permission_id, status); + if (pending_request->IsComplete()) { + pending_request->RunCallback(); + pending_requests_.Remove(request_id); } } void AtomPermissionManager::CancelPermissionRequest(int request_id) { - auto request = pending_requests_.find(request_id); - if (request != pending_requests_.end()) { - if (!WebContentsDestroyed(request->second.render_process_id)) - request->second.callback.Run(blink::mojom::PermissionStatus::DENIED); - pending_requests_.erase(request); - } + auto pending_request = pending_requests_.Lookup(request_id); + if (!pending_request) + return; + + if (!WebContentsDestroyed(pending_request->render_process_id())) + pending_request->RunCallback(); + pending_requests_.Remove(request_id); } void AtomPermissionManager::ResetPermission( @@ -143,7 +197,7 @@ int AtomPermissionManager::SubscribePermissionStatusChange( content::PermissionType permission, const GURL& requesting_origin, const GURL& embedding_origin, - const ResponseCallback& callback) { + const StatusCallback& callback) { return -1; } diff --git a/atom/browser/atom_permission_manager.h b/atom/browser/atom_permission_manager.h index 39072614a3f9..7b74fe3fba4a 100644 --- a/atom/browser/atom_permission_manager.h +++ b/atom/browser/atom_permission_manager.h @@ -9,6 +9,7 @@ #include #include "base/callback.h" +#include "base/id_map.h" #include "content/public/browser/permission_manager.h" namespace content { @@ -22,12 +23,14 @@ class AtomPermissionManager : public content::PermissionManager { AtomPermissionManager(); ~AtomPermissionManager() override; - using ResponseCallback = + using StatusCallback = base::Callback; + using StatusesCallback = + base::Callback&)>; using RequestHandler = base::Callback; + const StatusCallback&)>; // Handler to dispatch permission requests in JS. void SetPermissionRequestHandler(const RequestHandler& handler); @@ -51,8 +54,7 @@ class AtomPermissionManager : public content::PermissionManager { protected: void OnPermissionResponse(int request_id, - const GURL& url, - const ResponseCallback& callback, + int permission_id, blink::mojom::PermissionStatus status); // content::PermissionManager: @@ -76,16 +78,12 @@ class AtomPermissionManager : public content::PermissionManager { void UnsubscribePermissionStatusChange(int subscription_id) override; private: - struct RequestInfo { - int render_process_id; - ResponseCallback callback; - }; + class PendingRequest; + using PendingRequestsMap = IDMap; RequestHandler request_handler_; - std::map pending_requests_; - - int request_id_; + PendingRequestsMap pending_requests_; DISALLOW_COPY_AND_ASSIGN(AtomPermissionManager); };