renderer: implement multiple permission requesting

content/child/permissions/permission_dispatcher.h

 // 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.
 
 #ifndef CONTENT_CHILD_PERMISSIONS_PERMISSION_DISPATCHER_H_
 #define CONTENT_CHILD_PERMISSIONS_PERMISSION_DISPATCHER_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
@@ skipping 25 matching lines @@
   explicit PermissionDispatcher(ServiceRegistry* service_registry);
   virtual ~PermissionDispatcher();
 
   // blink::WebPermissionClient implementation.
   virtual void queryPermission(blink::WebPermissionType type,
                                const blink::WebURL& origin,
                                blink::WebPermissionCallback* callback);
   virtual void requestPermission(blink::WebPermissionType,
                                  const blink::WebURL& origin,
                                  blink::WebPermissionCallback* callback);
+  virtual void requestPermissions(
+      const blink::WebVector<blink::WebPermissionType>& types,
+      const blink::WebURL& origin,
+      blink::WebPermissionsCallback* callback);
   virtual void revokePermission(blink::WebPermissionType,
                                 const blink::WebURL& origin,
                                 blink::WebPermissionCallback* callback);
   virtual void startListening(blink::WebPermissionType type,
                               const blink::WebURL& origin,
                               blink::WebPermissionObserver* observer);
   virtual void stopListening(blink::WebPermissionObserver* observer);
 
   // The following methods must be called by workers on the main thread.
   void QueryPermissionForWorker(blink::WebPermissionType type,
                                 const std::string& origin,
                                 blink::WebPermissionCallback* callback,
                                 int worker_thread_id);
   void RequestPermissionForWorker(blink::WebPermissionType type,
                                   const std::string& origin,
                                   blink::WebPermissionCallback* callback,
                                   int worker_thread_id);
+  void RequestPermissionsForWorker(
+      const blink::WebVector<blink::WebPermissionType>& types,
+      const std::string& origin,
+      blink::WebPermissionsCallback* callback,
+      int worker_thread_id);
   void RevokePermissionForWorker(blink::WebPermissionType type,
                                  const std::string& origin,
                                  blink::WebPermissionCallback* callback,
                                  int worker_thread_id);
   void StartListeningForWorker(
       blink::WebPermissionType type,
       const std::string& origin,
       int worker_thread_id,
       const base::Callback<void(blink::WebPermissionStatus)>& callback);
   void GetNextPermissionChangeForWorker(
       blink::WebPermissionType type,
       const std::string& origin,
       blink::WebPermissionStatus status,
       int worker_thread_id,
       const base::Callback<void(blink::WebPermissionStatus)>& callback);
 
  private:
   // Runs the given |callback| with |status| as a parameter. It has to be run
   // on a worker thread.
   static void RunCallbackOnWorkerThread(
       blink::WebPermissionCallback* callback,
       scoped_ptr<blink::WebPermissionStatus> status);
+  static void RunMultiCallbackOnWorkerThread(

[mlamouri (slow - plz ping), 2015/08/18 13:37:15]

I think it's find to overload RunCallbackOnWorkerThread.

[Lalit Maganti, 2015/08/20 14:23:30]

Can't actually do this because I use it in a callback and bind does not support
overloading.

+      blink::WebPermissionsCallback* callback,
+      scoped_ptr<blink::WebVector<blink::WebPermissionStatus>> statuses);
 
   // Helper method that returns an initialized PermissionServicePtr.
   PermissionServicePtr& GetPermissionServicePtr();
 
   void QueryPermissionInternal(blink::WebPermissionType type,
                                const std::string& origin,
                                blink::WebPermissionCallback* callback,
                                int worker_thread_id);
   void RequestPermissionInternal(blink::WebPermissionType type,
                                 const std::string& origin,
                                 blink::WebPermissionCallback* callback,
                                 int worker_thread_id);
+  void RequestPermissionsInternal(
+      const blink::WebVector<blink::WebPermissionType>& types,
+      const std::string& origin,
+      blink::WebPermissionsCallback* callback,
+      int worker_thread_id);
   void RevokePermissionInternal(blink::WebPermissionType type,
                                 const std::string& origin,
                                 blink::WebPermissionCallback* callback,
                                 int worker_thread_id);
 
   // This is the callback function used for query and revoke
   void OnPermissionResponse(int request_id,
                             PermissionStatus status);
+  void OnPermissionsResponse(int request_id,
+                             const mojo::Array<PermissionStatus>& status);
   void OnPermissionChanged(blink::WebPermissionType type,
                            const std::string& origin,
                            blink::WebPermissionObserver* observer,
                            PermissionStatus status);
   void OnPermissionChangedForWorker(
       int worker_thread_id,
       const base::Callback<void(blink::WebPermissionStatus)>& callback,
       PermissionStatus status);
 
   void GetNextPermissionChange(blink::WebPermissionType type,
                                const std::string& origin,
                                blink::WebPermissionObserver* observer,
                                PermissionStatus current_status);
 
   // Saves some basic information about the callback in order to be able to run
   // it in the right thread.
+  template<typename T>
   class CallbackInformation {
    public:
-    CallbackInformation(blink::WebPermissionCallback* callback,
-                        int worker_thread_id);
-    ~CallbackInformation();
+    CallbackInformation(T* callback,
+                        int worker_thread_id)
+      : callback_(callback),
+        worker_thread_id_(worker_thread_id) {
+    }
 
-    blink::WebPermissionCallback* callback() const;
-    int worker_thread_id() const;
+    ~CallbackInformation() {}

[mlamouri (slow - plz ping), 2015/08/18 13:37:15]

nit: = default.

[Lalit Maganti, 2015/08/20 14:23:30]

Removed class.

 
-    blink::WebPermissionCallback* ReleaseCallback();
+    T* callback() const  {
+      return callback_.get();
+    }
+
+    int worker_thread_id() const {
+      return worker_thread_id_;
+    }
+
+    T* ReleaseCallback() {
+      return callback_.release();
+    }
 
    private:
-    scoped_ptr<blink::WebPermissionCallback> callback_;
+    scoped_ptr<T> callback_;
     int worker_thread_id_;
 
     DISALLOW_COPY_AND_ASSIGN(CallbackInformation);
   };
-  using CallbackMap = IDMap<CallbackInformation, IDMapOwnPointer>;
+
+  using SingleCallbackInfo = CallbackInformation<blink::WebPermissionCallback>;

[mlamouri (slow - plz ping), 2015/08/18 13:37:15]

I dislike the name to be honest. Maybe you could come up with a better one.
Otherwise simply using the full name?

[Lalit Maganti, 2015/08/20 14:23:30]

The reason I put the using is because the lines become far too long without
them.

I'll attempt to come up with a better name.

+  using CallbackMap = IDMap<SingleCallbackInfo, IDMapOwnPointer>;
   CallbackMap pending_callbacks_;
 
+  using MultiCallbackInfo = CallbackInformation<blink::WebPermissionsCallback>;

[mlamouri (slow - plz ping), 2015/08/18 13:37:15]

ditto.

[Lalit Maganti, 2015/08/20 14:23:30]

Acknowledged.

+  using MultipleCallbackMap = IDMap<MultiCallbackInfo, IDMapOwnPointer>;

[mlamouri (slow - plz ping), 2015/08/18 13:37:15]

Again, the name isn't clear. At least, add a comment.

[Lalit Maganti, 2015/08/20 14:23:30]

Acknowledged.

+  MultipleCallbackMap multiple_pending_callbacks_;
+
   ServiceRegistry* service_registry_;
   PermissionServicePtr permission_service_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionDispatcher);
 };
 
 }  // namespace content
 
 #endif // CONTENT_CHILD_PERMISSIONS_PERMISSION_DISPATCHER_H_