content/child/permissions/permission_manager.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/permissions/permission_manager.h"
   6
   7 #include "content/child/worker_task_runner.h"
   8 #include "content/public/common/service_registry.h"
   9 #include "third_party/WebKit/public/platform/WebURL.h"
  10
  11 namespace content {
  12
  13 namespace {
  14
  15 PermissionName GetPermissionName(blink::WebPermissionType type) {
  16   switch (type) {
  17     case blink::WebPermissionTypeGeolocation:
  18       return PERMISSION_NAME_GEOLOCATION;
  19     case blink::WebPermissionTypeNotifications:
  20       return PERMISSION_NAME_NOTIFICATIONS;
  21     case blink::WebPermissionTypePushNotifications:
  22       return PERMISSION_NAME_PUSH_NOTIFICATIONS;
  23     case blink::WebPermissionTypeMidiSysEx:
  24       return PERMISSION_NAME_MIDI_SYSEX;
  25     default:
  26       // The default statement is only there to prevent compilation failures if
  27       // WebPermissionType enum gets extended.
  28       NOTREACHED();
  29       return PERMISSION_NAME_GEOLOCATION;
  30   }
  31 }
  32
  33 blink::WebPermissionStatus GetWebPermissionStatus(PermissionStatus status) {
  34   switch (status) {
  35     case PERMISSION_STATUS_GRANTED:
  36       return blink::WebPermissionStatusGranted;
  37     case PERMISSION_STATUS_DENIED:
  38       return blink::WebPermissionStatusDenied;
  39     case PERMISSION_STATUS_ASK:
  40       return blink::WebPermissionStatusPrompt;
  41   }
  42
  43   NOTREACHED();
  44   return blink::WebPermissionStatusDenied;
  45 }
  46
  47 const int kNoWorkerThread = 0;
  48
  49 }  // anonymous namespace
  50
  51 PermissionManager::CallbackInformation::CallbackInformation(
  52     blink::WebPermissionQueryCallback* callback,
  53     int worker_thread_id)
  54   : callback_(callback),
  55     worker_thread_id_(worker_thread_id) {
  56 }
  57
  58 blink::WebPermissionQueryCallback*
  59 PermissionManager::CallbackInformation::callback() const {
  60   return callback_.get();
  61 }
  62
  63 int PermissionManager::CallbackInformation::worker_thread_id() const {
  64   return worker_thread_id_;
  65 }
  66
  67 blink::WebPermissionQueryCallback*
  68 PermissionManager::CallbackInformation::ReleaseCallback() {
  69   return callback_.release();
  70 }
  71
  72 PermissionManager::CallbackInformation::~CallbackInformation() {
  73 }
  74
  75 PermissionManager::PermissionManager(ServiceRegistry* service_registry)
  76     : service_registry_(service_registry) {
  77 }
  78
  79 PermissionManager::~PermissionManager() {
  80 }
  81
  82 void PermissionManager::queryPermission(
  83     blink::WebPermissionType type,
  84     const blink::WebURL& origin,
  85     blink::WebPermissionQueryCallback* callback) {
  86   QueryPermissionInternal(
  87       type, origin.string().utf8(), callback, kNoWorkerThread);
  88 }
  89
  90 void PermissionManager::QueryPermissionForWorker(
  91     blink::WebPermissionType type,
  92     const std::string& origin,
  93     blink::WebPermissionQueryCallback* callback,
  94     int worker_thread_id) {
  95   QueryPermissionInternal(type, origin, callback, worker_thread_id);
  96 }
  97
  98 void PermissionManager::QueryPermissionInternal(
  99     blink::WebPermissionType type,
 100     const std::string& origin,
 101     blink::WebPermissionQueryCallback* callback,
 102     int worker_thread_id) {
 103   // We need to save the |callback| in an IDMap so if |this| gets deleted, the
 104   // callback will not leak. In the case of |this| gets deleted, the
 105   // |permission_service_| pipe will be destroyed too so OnQueryPermission will
 106   // not be called.
 107   int request_id = pending_callbacks_.Add(
 108       new CallbackInformation(callback, worker_thread_id));
 109   if (!permission_service_.get())
 110     service_registry_->ConnectToRemoteService(&permission_service_);
 111   permission_service_->HasPermission(
 112       GetPermissionName(type),
 113       origin,
 114       base::Bind(&PermissionManager::OnQueryPermission,
 115                  base::Unretained(this),
 116                  request_id));
 117 }
 118
 119 void PermissionManager::OnQueryPermission(int request_id,
 120                                            PermissionStatus result) {
 121   CallbackInformation* callback_information =
 122       pending_callbacks_.Lookup(request_id);
 123   DCHECK(callback_information && callback_information->callback());
 124   scoped_ptr<blink::WebPermissionStatus> status(
 125       new blink::WebPermissionStatus(GetWebPermissionStatus(result)));
 126
 127   if (callback_information->worker_thread_id() != kNoWorkerThread) {
 128     blink::WebPermissionQueryCallback* callback =
 129         callback_information->ReleaseCallback();
 130     int worker_thread_id = callback_information->worker_thread_id();
 131     pending_callbacks_.Remove(request_id);
 132
 133     // If the worker is no longer running, ::PostTask() will return false and
 134     // gracefully fail, destroying the callback too.
 135     WorkerTaskRunner::Instance()->PostTask(
 136         worker_thread_id,
 137         base::Bind(&PermissionManager::RunCallbackOnWorkerThread,
 138                    base::Unretained(callback),
 139                    base::Passed(&status)));
 140     return;
 141   }
 142
 143   callback_information->callback()->onSuccess(status.release());
 144   pending_callbacks_.Remove(request_id);
 145 }
 146
 147 // static
 148 void PermissionManager::RunCallbackOnWorkerThread(
 149     blink::WebPermissionQueryCallback* callback,
 150     scoped_ptr<blink::WebPermissionStatus> status) {
 151   callback->onSuccess(status.release());
 152   delete callback;
 153 }
 154
 155 }  // namespace content