renderer: implement multiple permission requesting

content/child/permissions/permission_dispatcher.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/child/permissions/permission_dispatcher.h"
 
 #include "base/callback.h"
 #include "content/child/worker_task_runner.h"
 #include "content/public/common/service_registry.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
@@ skipping 84 matching lines @@
 }
 
 void PermissionDispatcher::requestPermission(
     blink::WebPermissionType type,
     const blink::WebURL& origin,
     blink::WebPermissionCallback* callback) {
   RequestPermissionInternal(
       type, origin.string().utf8(), callback, kNoWorkerThread);
 }
 
+void PermissionDispatcher::requestPermissions(
+    const blink::WebVector<blink::WebPermissionType>& types,
+    const blink::WebURL& origin,
+    blink::WebPermissionsCallback* callback) {
+  RequestPermissionsInternal(
+      types, origin.string().utf8(), callback, kNoWorkerThread);
+}
+
 void PermissionDispatcher::revokePermission(
     blink::WebPermissionType type,
     const blink::WebURL& origin,
     blink::WebPermissionCallback* callback) {
   RevokePermissionInternal(
       type, origin.string().utf8(), callback, kNoWorkerThread);
 }
 
 void PermissionDispatcher::startListening(
     blink::WebPermissionType type,
@@ skipping 29 matching lines @@
 }
 
 void PermissionDispatcher::RequestPermissionForWorker(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionCallback* callback,
     int worker_thread_id) {
   RequestPermissionInternal(type, origin, callback, worker_thread_id);
 }
 
+void PermissionDispatcher::RequestPermissionsForWorker(
+    const blink::WebVector<blink::WebPermissionType>& types,
+    const std::string& origin,
+    blink::WebPermissionsCallback* callback,
+    int worker_thread_id) {
+  RequestPermissionsInternal(types, origin, callback, worker_thread_id);
+}
+
 void PermissionDispatcher::RevokePermissionForWorker(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionCallback* callback,
     int worker_thread_id) {
   RevokePermissionInternal(type, origin, callback, worker_thread_id);
 }
 
 void PermissionDispatcher::StartListeningForWorker(
     blink::WebPermissionType type,
@@ skipping 31 matching lines @@
 }
 
 // static
 void PermissionDispatcher::RunCallbackOnWorkerThread(
     blink::WebPermissionCallback* callback,
     scoped_ptr<blink::WebPermissionStatus> status) {
   callback->onSuccess(status.release());
   delete callback;
 }
 
+void PermissionDispatcher::RunMultiCallbackOnWorkerThread(
+    blink::WebPermissionsCallback* callback,
+    scoped_ptr<blink::WebVector<blink::WebPermissionStatus>> statuses) {
+  callback->onSuccess(blink::adoptWebPtr(statuses.release()));
+  delete callback;
+}
+
 PermissionServicePtr& PermissionDispatcher::GetPermissionServicePtr() {
   if (!permission_service_.get()) {
     service_registry_->ConnectToRemoteService(
         mojo::GetProxy(&permission_service_));
   }
   return permission_service_;
 }
 
 void PermissionDispatcher::QueryPermissionInternal(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionCallback* callback,
     int worker_thread_id) {
   // We need to save the |callback| in an ScopedVector so if |this| gets
   // deleted, the callback will not leak. In the case of |this| gets deleted,
   // the |permission_service_| pipe will be destroyed too so OnQueryPermission
   // will not be called.
   PendingCallbackVector::iterator iterator =
       pending_callbacks_.insert(pending_callbacks_.end(), callback);
-

[mlamouri (slow - plz ping), 2015/08/21 10:24:41]

nit: revert that change

[Lalit Maganti, 2015/08/25 16:58:27]

Done.

   GetPermissionServicePtr()->HasPermission(
       GetPermissionName(type),
       origin,
       base::Bind(&PermissionDispatcher::OnPermissionResponse,
                  base::Unretained(this),
                  worker_thread_id,
                  iterator));
 }
 
 void PermissionDispatcher::RequestPermissionInternal(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionCallback* callback,
     int worker_thread_id) {
   // We need to save the |callback| in an ScopedVector so if |this| gets
   // deleted, the callback will not leak. In the case of |this| gets deleted,
   // the |permission_service_| pipe will be destroyed too so OnQueryPermission
   // will not be called.
   PendingCallbackVector::iterator iterator =
       pending_callbacks_.insert(pending_callbacks_.end(), callback);
-

[mlamouri (slow - plz ping), 2015/08/21 10:24:41]

ditto

[Lalit Maganti, 2015/08/25 16:58:27]

Done.

   GetPermissionServicePtr()->RequestPermission(
       GetPermissionName(type),
       origin,
       blink::WebUserGestureIndicator::isProcessingUserGesture(),
       base::Bind(&PermissionDispatcher::OnPermissionResponse,
                  base::Unretained(this),
                  worker_thread_id,
                  iterator));
 }
 
+void PermissionDispatcher::RequestPermissionsInternal(
+    const blink::WebVector<blink::WebPermissionType>& types,
+    const std::string& origin,
+    blink::WebPermissionsCallback* callback,
+    int worker_thread_id) {
+  // We need to save the |callback| in an ScopedVector so if |this| gets
+  // deleted, the callback will not leak. In the case of |this| gets deleted,
+  // the |permission_service_| pipe will be destroyed too so OnQueryPermission
+  // will not be called.
+  PendingBatchCallbackVector::iterator iterator =
+      batch_pending_callbacks_.insert(batch_pending_callbacks_.end(), callback);

[mlamouri (slow - plz ping), 2015/08/21 10:24:41]

I guess this needs to be rebased.

[Lalit Maganti, 2015/08/25 16:58:27]

Done.

+
+  mojo::Array<PermissionName> names(types.size());
+  for (size_t i = 0; i < types.size(); ++i)
+    names[i] = GetPermissionName(types[i]);
+
+  GetPermissionServicePtr()->RequestBatchPermission(
+      names.Pass(),
+      origin,
+      blink::WebUserGestureIndicator::isProcessingUserGesture(),
+      base::Bind(&PermissionDispatcher::OnPermissionsResponse,
+                 base::Unretained(this),
+                 worker_thread_id,
+                 iterator));
+}
+
 void PermissionDispatcher::RevokePermissionInternal(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionCallback* callback,
     int worker_thread_id) {
   // We need to save the |callback| in an ScopedVector so if |this| gets
   // deleted, the callback will not leak. In the case of |this| gets deleted,
   // the |permission_service_| pipe will be destroyed too so OnQueryPermission
   // will not be called.
   PendingCallbackVector::iterator iterator =
       pending_callbacks_.insert(pending_callbacks_.end(), callback);
-
   GetPermissionServicePtr()->RevokePermission(
       GetPermissionName(type),
       origin,
       base::Bind(&PermissionDispatcher::OnPermissionResponse,
                  base::Unretained(this),
                  worker_thread_id,
                  iterator));
 }
 
 void PermissionDispatcher::OnPermissionResponse(
@@ skipping 14 matching lines @@
         base::Bind(&PermissionDispatcher::RunCallbackOnWorkerThread,
                    base::Unretained(callback),
                    base::Passed(&status)));
     return;
   }
 
   callback->onSuccess(status.release());
   pending_callbacks_.erase(callback_iterator);
 }
 
+void PermissionDispatcher::OnPermissionsResponse(
+    int worker_thread_id,
+    PendingBatchCallbackVector::iterator callback_iterator,
+    const mojo::Array<PermissionStatus>& result) {
+  blink::WebPermissionsCallback* callback = *callback_iterator;
+  scoped_ptr<blink::WebVector<blink::WebPermissionStatus>> statuses(
+      new blink::WebVector<blink::WebPermissionStatus>(result.size()));
+
+  for (size_t i = 0; i < result.size(); i++)
+    statuses->operator[](i) = GetWebPermissionStatus(result[i]);
+
+  if (worker_thread_id != kNoWorkerThread) {
+    batch_pending_callbacks_.weak_erase(callback_iterator);
+
+    // If the worker is no longer running, ::PostTask() will return false and
+    // gracefully fail, destroying the callback too.
+    WorkerTaskRunner::Instance()->PostTask(
+        worker_thread_id,
+        base::Bind(&PermissionDispatcher::RunMultiCallbackOnWorkerThread,
+                   base::Unretained(callback),
+                   base::Passed(&statuses)));
+    return;
+  }
+
+  callback->onSuccess(blink::adoptWebPtr(statuses.release()));
+  batch_pending_callbacks_.erase(callback_iterator);
+}
+
 void PermissionDispatcher::OnPermissionChanged(
     blink::WebPermissionType type,
     const std::string& origin,
     WebPermissionObserver* observer,
     PermissionStatus status) {
   if (!IsObserverRegistered(observer))
     return;
 
   observer->permissionChanged(type, GetWebPermissionStatus(status));
 
@@ skipping 20 matching lines @@
       origin,
       current_status,
       base::Bind(&PermissionDispatcher::OnPermissionChanged,
                  base::Unretained(this),
                  type,
                  origin,
                  base::Unretained(observer)));
 }
 
 }  // namespace content