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 with an arbitrary value because the
+                          // mojo service wants a value. Worst 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(
+      GetPermissionName(type),
+      origin,
+      // We initialize with an arbitrary value because the mojo service wants a
+      // value. Worst 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)));
+}
+
+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