Permissions: glue between Mojo and Blink for permission observing.

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"
+#include "third_party/WebKit/public/platform/modules/permissions/WebPermissionObserver.h"
+
+using blink::WebPermissionObserver;
 
 namespace content {
 
 namespace {
 
 PermissionName GetPermissionName(blink::WebPermissionType type) {
   switch (type) {
     case blink::WebPermissionTypeGeolocation:
       return PERMISSION_NAME_GEOLOCATION;
     case blink::WebPermissionTypeNotifications:
       return PERMISSION_NAME_NOTIFICATIONS;
     case blink::WebPermissionTypePushNotifications:
       return PERMISSION_NAME_PUSH_NOTIFICATIONS;
     case blink::WebPermissionTypeMidiSysEx:
       return PERMISSION_NAME_MIDI_SYSEX;
     default:
       // The default statement is only there to prevent compilation failures if
       // WebPermissionType enum gets extended.
       NOTREACHED();
       return PERMISSION_NAME_GEOLOCATION;
   }
 }
 
+PermissionStatus GetPermissionStatus(blink::WebPermissionStatus status) {
+  switch (status) {
+    case blink::WebPermissionStatusGranted:
+      return PERMISSION_STATUS_GRANTED;
+    case blink::WebPermissionStatusDenied:
+      return PERMISSION_STATUS_DENIED;
+    case blink::WebPermissionStatusPrompt:
+      return PERMISSION_STATUS_ASK;
+  }
+
+  NOTREACHED();
+  return PERMISSION_STATUS_DENIED;
+}
+
 blink::WebPermissionStatus GetWebPermissionStatus(PermissionStatus status) {
   switch (status) {
     case PERMISSION_STATUS_GRANTED:
       return blink::WebPermissionStatusGranted;
     case PERMISSION_STATUS_DENIED:
       return blink::WebPermissionStatusDenied;
     case PERMISSION_STATUS_ASK:
       return blink::WebPermissionStatusPrompt;
   }
 
   NOTREACHED();
   return blink::WebPermissionStatusDenied;
 }
 
 const int kNoWorkerThread = 0;
 
 }  // anonymous namespace
 
+// static
+bool PermissionDispatcher::IsObservable(blink::WebPermissionType type) {
+  return type == blink::WebPermissionTypeGeolocation ||
+         type == blink::WebPermissionTypeNotifications ||
+         type == blink::WebPermissionTypePushNotifications ||
+         type == blink::WebPermissionTypeMidiSysEx;
+}
+
 PermissionDispatcher::CallbackInformation::CallbackInformation(
     blink::WebPermissionQueryCallback* callback,
     int worker_thread_id)
   : callback_(callback),
     worker_thread_id_(worker_thread_id) {
 }
 
 blink::WebPermissionQueryCallback*
 PermissionDispatcher::CallbackInformation::callback() const {
   return callback_.get();
@@ skipping 19 matching lines @@
 }
 
 void PermissionDispatcher::queryPermission(
     blink::WebPermissionType type,
     const blink::WebURL& origin,
     blink::WebPermissionQueryCallback* callback) {
   QueryPermissionInternal(
       type, origin.string().utf8(), callback, kNoWorkerThread);
 }
 
+void PermissionDispatcher::startListening(
+    blink::WebPermissionType type,
+    const blink::WebURL& origin,
+    WebPermissionObserver* observer) {
+  if (!IsObservable(type))
+    return;
+
+  RegisterObserver(observer);
+
+  GetNextPermissionChange(type,
+                          origin.string().utf8(),
+                          observer,
+                          // We initialize we an arbitrary value because the

[whywhat, 2015/04/02 16:20:23]

nits:
s/we/with
s/worse/worst

[mlamouri (slow - plz ping), 2015/04/02 17:02:43]

Done.

+                          // mojo service wants a value. Worse case, the
+                          // observer will get notified about a non-change which
+                          // should be a no-op. After the first notification,
+                          // GetNextPermissionChange will be called with the
+                          // latest known value.
+                          PERMISSION_STATUS_ASK);
+}
+
+void PermissionDispatcher::stopListening(WebPermissionObserver* observer) {
+  UnregisterObserver(observer);
+}
+
 void PermissionDispatcher::QueryPermissionForWorker(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionQueryCallback* callback,
     int worker_thread_id) {
   QueryPermissionInternal(type, origin, callback, worker_thread_id);
 }
 
+void PermissionDispatcher::StartListeningForWorker(
+    blink::WebPermissionType type,
+    const std::string& origin,
+    int worker_thread_id,
+    const base::Callback<void(blink::WebPermissionStatus)>& callback) {
+  GetPermissionServicePtr()->GetNextPermissionChange(

[whywhat, 2015/04/02 16:20:23]

shouldn't you call the internal GetNextPermissionChange method to avoid some
redundancy and confusion? it could take the callback as an argument and you
could move the default callback to some extra helper function?

Right now there's three methods that seem to be used without a clear pattern:
GetNextPermissionChange (looks like a helper function, called from a couple of
places without the callback)
GetNextPermissionChangeForWorker (public for some reason, does almost exactly
the same thing as startListeningForWorker())
GetPermissionServicePtr()->GetNextPermissionChange() that's called from three
places with slightly different params.

[mlamouri (slow - plz ping), 2015/04/02 17:02:42]

I see what you mean but they are slightly different. Would you mind if I do that
in a follow-up?

+      GetPermissionName(type),
+      origin,
+      // We initialize we an arbitrary value because the mojo service wants a

[whywhat, 2015/04/02 16:20:23]

nits:
s/we/with
s/worse/worst

[mlamouri (slow - plz ping), 2015/04/02 17:02:43]

Done.

+      // value. Worse case, the observer will get notified about a non-change
+      // which should be a no-op. After the first notification,
+      // GetNextPermissionChange will be called with the latest known value.
+      PERMISSION_STATUS_ASK,
+      base::Bind(&PermissionDispatcher::OnPermissionChangedForWorker,
+                 base::Unretained(this),
+                 worker_thread_id,
+                 callback));
+}
+
+void PermissionDispatcher::GetNextPermissionChangeForWorker(
+    blink::WebPermissionType type,
+    const std::string& origin,
+    blink::WebPermissionStatus status,
+    int worker_thread_id,
+    const base::Callback<void(blink::WebPermissionStatus)>& callback) {
+  GetPermissionServicePtr()->GetNextPermissionChange(
+      GetPermissionName(type),
+      origin,
+      GetPermissionStatus(status),
+      base::Bind(&PermissionDispatcher::OnPermissionChangedForWorker,
+                 base::Unretained(this),
+                 worker_thread_id,
+                 callback));
+}
+
+// static
+void PermissionDispatcher::RunCallbackOnWorkerThread(
+    blink::WebPermissionQueryCallback* callback,
+    scoped_ptr<blink::WebPermissionStatus> status) {
+  callback->onSuccess(status.release());
+  delete callback;
+}
+
+PermissionServicePtr& PermissionDispatcher::GetPermissionServicePtr() {
+  if (!permission_service_.get())
+    service_registry_->ConnectToRemoteService(&permission_service_);
+  return permission_service_;
+}
+
 void PermissionDispatcher::QueryPermissionInternal(
     blink::WebPermissionType type,
     const std::string& origin,
     blink::WebPermissionQueryCallback* callback,
     int worker_thread_id) {
   // We need to save the |callback| in an IDMap 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.
   int request_id = pending_callbacks_.Add(
       new CallbackInformation(callback, worker_thread_id));
-  if (!permission_service_.get())
-    service_registry_->ConnectToRemoteService(&permission_service_);
-  permission_service_->HasPermission(
+  GetPermissionServicePtr()->HasPermission(
       GetPermissionName(type),
       origin,
       base::Bind(&PermissionDispatcher::OnQueryPermission,
                  base::Unretained(this),
                  request_id));
 }
 
 void PermissionDispatcher::OnQueryPermission(int request_id,
-                                           PermissionStatus result) {
+                                             PermissionStatus result) {
   CallbackInformation* callback_information =
       pending_callbacks_.Lookup(request_id);
   DCHECK(callback_information && callback_information->callback());
   scoped_ptr<blink::WebPermissionStatus> status(
       new blink::WebPermissionStatus(GetWebPermissionStatus(result)));
 
   if (callback_information->worker_thread_id() != kNoWorkerThread) {
     blink::WebPermissionQueryCallback* callback =
         callback_information->ReleaseCallback();
     int worker_thread_id = callback_information->worker_thread_id();
     pending_callbacks_.Remove(request_id);
 
     // 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::RunCallbackOnWorkerThread,
                    base::Unretained(callback),
                    base::Passed(&status)));
     return;
   }
 
   callback_information->callback()->onSuccess(status.release());
   pending_callbacks_.Remove(request_id);
 }
 
-// static
-void PermissionDispatcher::RunCallbackOnWorkerThread(
-    blink::WebPermissionQueryCallback* callback,
-    scoped_ptr<blink::WebPermissionStatus> status) {
-  callback->onSuccess(status.release());
-  delete callback;
+void PermissionDispatcher::OnPermissionChanged(
+    blink::WebPermissionType type,
+    const std::string& origin,
+    WebPermissionObserver* observer,
+    PermissionStatus status) {
+  if (!IsObserverRegistered(observer))
+    return;
+
+  observer->permissionChanged(type, GetWebPermissionStatus(status));
+
+  GetNextPermissionChange(type, origin, observer, status);
+}
+
+void PermissionDispatcher::OnPermissionChangedForWorker(
+    int worker_thread_id,
+    const base::Callback<void(blink::WebPermissionStatus)>& callback,
+    PermissionStatus status) {
+  DCHECK(worker_thread_id != kNoWorkerThread);
+
+  WorkerTaskRunner::Instance()->PostTask(
+      worker_thread_id, base::Bind(callback, GetWebPermissionStatus(status)));

[whywhat, 2015/04/02 16:20:23]

You don't use RunCallbackOnWorkerThread here?

[mlamouri (slow - plz ping), 2015/04/02 17:02:43]

The reason is that I need to check whether the observer is still registered
before running the callback (which requires going back to the thread proxy).
Then, I need to go back to the main thread in order to get the next permission
change.

+}
+
+void PermissionDispatcher::GetNextPermissionChange(
+    blink::WebPermissionType type,
+    const std::string& origin,
+    WebPermissionObserver* observer,
+    PermissionStatus current_status) {
+  GetPermissionServicePtr()->GetNextPermissionChange(
+      GetPermissionName(type),
+      origin,
+      current_status,
+      base::Bind(&PermissionDispatcher::OnPermissionChanged,
+                 base::Unretained(this),
+                 type,
+                 origin,
+                 base::Unretained(observer)));
 }
 
 }  // namespace content