content/child/permissions/permission_dispatcher_thread_proxy.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_dispatcher_thread_proxy.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/lazy_instance.h"
  10 #include "base/location.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/threading/thread_local.h"
  13 #include "content/child/permissions/permission_dispatcher.h"
  14 #include "content/child/worker_task_runner.h"
  15 #include "third_party/WebKit/public/platform/WebURL.h"
  16 #include "third_party/WebKit/public/platform/modules/permissions/WebPermissionObserver.h"
  17
  18 using base::LazyInstance;
  19 using base::ThreadLocalPointer;
  20
  21 namespace content {
  22
  23 namespace {
  24
  25 LazyInstance<ThreadLocalPointer<PermissionDispatcherThreadProxy>>::Leaky
  26     g_permission_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
  27
  28 }  // anonymous namespace
  29
  30 PermissionDispatcherThreadProxy*
  31 PermissionDispatcherThreadProxy::GetThreadInstance(
  32     base::SingleThreadTaskRunner* main_thread_task_runner,
  33     PermissionDispatcher* permission_dispatcher) {
  34   if (g_permission_dispatcher_tls.Pointer()->Get())
  35     return g_permission_dispatcher_tls.Pointer()->Get();
  36
  37   PermissionDispatcherThreadProxy* instance =
  38       new PermissionDispatcherThreadProxy(main_thread_task_runner,
  39                                         permission_dispatcher);
  40   DCHECK(WorkerTaskRunner::Instance()->CurrentWorkerId());
  41   WorkerTaskRunner::Instance()->AddStopObserver(instance);
  42   return instance;
  43 }
  44
  45 PermissionDispatcherThreadProxy::PermissionDispatcherThreadProxy(
  46     base::SingleThreadTaskRunner* main_thread_task_runner,
  47     PermissionDispatcher* permission_dispatcher)
  48   : main_thread_task_runner_(main_thread_task_runner),
  49     permission_dispatcher_(permission_dispatcher) {
  50   g_permission_dispatcher_tls.Pointer()->Set(this);
  51 }
  52
  53 PermissionDispatcherThreadProxy::~PermissionDispatcherThreadProxy() {
  54   g_permission_dispatcher_tls.Pointer()->Set(nullptr);
  55 }
  56
  57 void PermissionDispatcherThreadProxy::queryPermission(
  58     blink::WebPermissionType type,
  59     const blink::WebURL& origin,
  60     blink::WebPermissionCallback* callback) {
  61   main_thread_task_runner_->PostTask(
  62       FROM_HERE,
  63       base::Bind(&PermissionDispatcher::QueryPermissionForWorker,
  64                  base::Unretained(permission_dispatcher_),
  65                  type,
  66                  origin.string().utf8(),
  67                  base::Unretained(callback),
  68                  WorkerTaskRunner::Instance()->CurrentWorkerId()));
  69 }
  70
  71 void PermissionDispatcherThreadProxy::revokePermission(
  72     blink::WebPermissionType type,
  73     const blink::WebURL& origin,
  74     blink::WebPermissionCallback* callback) {
  75   main_thread_task_runner_->PostTask(
  76       FROM_HERE,
  77       base::Bind(&PermissionDispatcher::RevokePermissionForWorker,
  78                  base::Unretained(permission_dispatcher_),
  79                  type,
  80                  origin.string().utf8(),
  81                  base::Unretained(callback),
  82                  WorkerTaskRunner::Instance()->CurrentWorkerId()));
  83 }
  84
  85 void PermissionDispatcherThreadProxy::startListening(
  86     blink::WebPermissionType type,
  87     const blink::WebURL& origin,
  88     blink::WebPermissionObserver* observer) {
  89   if (!PermissionDispatcher::IsObservable(type))
  90     return;
  91
  92   RegisterObserver(observer);
  93
  94   main_thread_task_runner_->PostTask(FROM_HERE,
  95       base::Bind(&PermissionDispatcher::StartListeningForWorker,
  96           base::Unretained(permission_dispatcher_),
  97           type,
  98           origin.string().utf8(),
  99           WorkerTaskRunner::Instance()->CurrentWorkerId(),
 100           base::Bind(&PermissionDispatcherThreadProxy::OnPermissionChanged,
 101                      base::Unretained(this),
 102                      type,
 103                      origin.string().utf8(),
 104                      base::Unretained(observer))));
 105 }
 106
 107 void PermissionDispatcherThreadProxy::stopListening(
 108     blink::WebPermissionObserver* observer) {
 109   UnregisterObserver(observer);
 110 }
 111
 112 void PermissionDispatcherThreadProxy::OnPermissionChanged(
 113     blink::WebPermissionType type,
 114     const std::string& origin,
 115     blink::WebPermissionObserver* observer,
 116     blink::WebPermissionStatus status) {
 117   if (!IsObserverRegistered(observer))
 118     return;
 119
 120   observer->permissionChanged(type, status);
 121
 122   main_thread_task_runner_->PostTask(FROM_HERE,
 123       base::Bind(&PermissionDispatcher::GetNextPermissionChangeForWorker,
 124           base::Unretained(permission_dispatcher_),
 125           type,
 126           origin,
 127           status,
 128           WorkerTaskRunner::Instance()->CurrentWorkerId(),
 129           base::Bind(&PermissionDispatcherThreadProxy::OnPermissionChanged,
 130                      base::Unretained(this),
 131                      type,
 132                      origin,
 133                      base::Unretained(observer))));
 134 }
 135
 136 void PermissionDispatcherThreadProxy::OnWorkerRunLoopStopped() {
 137   delete this;
 138 }
 139
 140 }  // namespace content