OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/child/permissions/permission_dispatcher.h" | 5 #include "content/child/permissions/permission_dispatcher.h" |
6 | 6 |
| 7 #include "base/callback.h" |
7 #include "content/child/worker_task_runner.h" | 8 #include "content/child/worker_task_runner.h" |
8 #include "content/public/common/service_registry.h" | 9 #include "content/public/common/service_registry.h" |
9 #include "third_party/WebKit/public/platform/WebURL.h" | 10 #include "third_party/WebKit/public/platform/WebURL.h" |
| 11 #include "third_party/WebKit/public/platform/modules/permissions/WebPermissionOb
server.h" |
| 12 |
| 13 using blink::WebPermissionObserver; |
10 | 14 |
11 namespace content { | 15 namespace content { |
12 | 16 |
13 namespace { | 17 namespace { |
14 | 18 |
15 PermissionName GetPermissionName(blink::WebPermissionType type) { | 19 PermissionName GetPermissionName(blink::WebPermissionType type) { |
16 switch (type) { | 20 switch (type) { |
17 case blink::WebPermissionTypeGeolocation: | 21 case blink::WebPermissionTypeGeolocation: |
18 return PERMISSION_NAME_GEOLOCATION; | 22 return PERMISSION_NAME_GEOLOCATION; |
19 case blink::WebPermissionTypeNotifications: | 23 case blink::WebPermissionTypeNotifications: |
20 return PERMISSION_NAME_NOTIFICATIONS; | 24 return PERMISSION_NAME_NOTIFICATIONS; |
21 case blink::WebPermissionTypePushNotifications: | 25 case blink::WebPermissionTypePushNotifications: |
22 return PERMISSION_NAME_PUSH_NOTIFICATIONS; | 26 return PERMISSION_NAME_PUSH_NOTIFICATIONS; |
23 case blink::WebPermissionTypeMidiSysEx: | 27 case blink::WebPermissionTypeMidiSysEx: |
24 return PERMISSION_NAME_MIDI_SYSEX; | 28 return PERMISSION_NAME_MIDI_SYSEX; |
25 default: | 29 default: |
26 // The default statement is only there to prevent compilation failures if | 30 // The default statement is only there to prevent compilation failures if |
27 // WebPermissionType enum gets extended. | 31 // WebPermissionType enum gets extended. |
28 NOTREACHED(); | 32 NOTREACHED(); |
29 return PERMISSION_NAME_GEOLOCATION; | 33 return PERMISSION_NAME_GEOLOCATION; |
30 } | 34 } |
31 } | 35 } |
32 | 36 |
| 37 PermissionStatus GetPermissionStatus(blink::WebPermissionStatus status) { |
| 38 switch (status) { |
| 39 case blink::WebPermissionStatusGranted: |
| 40 return PERMISSION_STATUS_GRANTED; |
| 41 case blink::WebPermissionStatusDenied: |
| 42 return PERMISSION_STATUS_DENIED; |
| 43 case blink::WebPermissionStatusPrompt: |
| 44 return PERMISSION_STATUS_ASK; |
| 45 } |
| 46 |
| 47 NOTREACHED(); |
| 48 return PERMISSION_STATUS_DENIED; |
| 49 } |
| 50 |
33 blink::WebPermissionStatus GetWebPermissionStatus(PermissionStatus status) { | 51 blink::WebPermissionStatus GetWebPermissionStatus(PermissionStatus status) { |
34 switch (status) { | 52 switch (status) { |
35 case PERMISSION_STATUS_GRANTED: | 53 case PERMISSION_STATUS_GRANTED: |
36 return blink::WebPermissionStatusGranted; | 54 return blink::WebPermissionStatusGranted; |
37 case PERMISSION_STATUS_DENIED: | 55 case PERMISSION_STATUS_DENIED: |
38 return blink::WebPermissionStatusDenied; | 56 return blink::WebPermissionStatusDenied; |
39 case PERMISSION_STATUS_ASK: | 57 case PERMISSION_STATUS_ASK: |
40 return blink::WebPermissionStatusPrompt; | 58 return blink::WebPermissionStatusPrompt; |
41 } | 59 } |
42 | 60 |
43 NOTREACHED(); | 61 NOTREACHED(); |
44 return blink::WebPermissionStatusDenied; | 62 return blink::WebPermissionStatusDenied; |
45 } | 63 } |
46 | 64 |
47 const int kNoWorkerThread = 0; | 65 const int kNoWorkerThread = 0; |
48 | 66 |
49 } // anonymous namespace | 67 } // anonymous namespace |
50 | 68 |
| 69 // static |
| 70 bool PermissionDispatcher::IsObservable(blink::WebPermissionType type) { |
| 71 return type == blink::WebPermissionTypeGeolocation || |
| 72 type == blink::WebPermissionTypeNotifications || |
| 73 type == blink::WebPermissionTypePushNotifications || |
| 74 type == blink::WebPermissionTypeMidiSysEx; |
| 75 } |
| 76 |
51 PermissionDispatcher::CallbackInformation::CallbackInformation( | 77 PermissionDispatcher::CallbackInformation::CallbackInformation( |
52 blink::WebPermissionQueryCallback* callback, | 78 blink::WebPermissionQueryCallback* callback, |
53 int worker_thread_id) | 79 int worker_thread_id) |
54 : callback_(callback), | 80 : callback_(callback), |
55 worker_thread_id_(worker_thread_id) { | 81 worker_thread_id_(worker_thread_id) { |
56 } | 82 } |
57 | 83 |
58 blink::WebPermissionQueryCallback* | 84 blink::WebPermissionQueryCallback* |
59 PermissionDispatcher::CallbackInformation::callback() const { | 85 PermissionDispatcher::CallbackInformation::callback() const { |
60 return callback_.get(); | 86 return callback_.get(); |
(...skipping 19 matching lines...) Expand all Loading... |
80 } | 106 } |
81 | 107 |
82 void PermissionDispatcher::queryPermission( | 108 void PermissionDispatcher::queryPermission( |
83 blink::WebPermissionType type, | 109 blink::WebPermissionType type, |
84 const blink::WebURL& origin, | 110 const blink::WebURL& origin, |
85 blink::WebPermissionQueryCallback* callback) { | 111 blink::WebPermissionQueryCallback* callback) { |
86 QueryPermissionInternal( | 112 QueryPermissionInternal( |
87 type, origin.string().utf8(), callback, kNoWorkerThread); | 113 type, origin.string().utf8(), callback, kNoWorkerThread); |
88 } | 114 } |
89 | 115 |
| 116 void PermissionDispatcher::startListening( |
| 117 blink::WebPermissionType type, |
| 118 const blink::WebURL& origin, |
| 119 WebPermissionObserver* observer) { |
| 120 if (!IsObservable(type)) |
| 121 return; |
| 122 |
| 123 RegisterObserver(observer); |
| 124 |
| 125 GetNextPermissionChange(type, |
| 126 origin.string().utf8(), |
| 127 observer, |
| 128 // We initialize with an arbitrary value because the |
| 129 // mojo service wants a value. Worst case, the |
| 130 // observer will get notified about a non-change which |
| 131 // should be a no-op. After the first notification, |
| 132 // GetNextPermissionChange will be called with the |
| 133 // latest known value. |
| 134 PERMISSION_STATUS_ASK); |
| 135 } |
| 136 |
| 137 void PermissionDispatcher::stopListening(WebPermissionObserver* observer) { |
| 138 UnregisterObserver(observer); |
| 139 } |
| 140 |
90 void PermissionDispatcher::QueryPermissionForWorker( | 141 void PermissionDispatcher::QueryPermissionForWorker( |
91 blink::WebPermissionType type, | 142 blink::WebPermissionType type, |
92 const std::string& origin, | 143 const std::string& origin, |
93 blink::WebPermissionQueryCallback* callback, | 144 blink::WebPermissionQueryCallback* callback, |
94 int worker_thread_id) { | 145 int worker_thread_id) { |
95 QueryPermissionInternal(type, origin, callback, worker_thread_id); | 146 QueryPermissionInternal(type, origin, callback, worker_thread_id); |
96 } | 147 } |
97 | 148 |
| 149 void PermissionDispatcher::StartListeningForWorker( |
| 150 blink::WebPermissionType type, |
| 151 const std::string& origin, |
| 152 int worker_thread_id, |
| 153 const base::Callback<void(blink::WebPermissionStatus)>& callback) { |
| 154 GetPermissionServicePtr()->GetNextPermissionChange( |
| 155 GetPermissionName(type), |
| 156 origin, |
| 157 // We initialize with an arbitrary value because the mojo service wants a |
| 158 // value. Worst case, the observer will get notified about a non-change |
| 159 // which should be a no-op. After the first notification, |
| 160 // GetNextPermissionChange will be called with the latest known value. |
| 161 PERMISSION_STATUS_ASK, |
| 162 base::Bind(&PermissionDispatcher::OnPermissionChangedForWorker, |
| 163 base::Unretained(this), |
| 164 worker_thread_id, |
| 165 callback)); |
| 166 } |
| 167 |
| 168 void PermissionDispatcher::GetNextPermissionChangeForWorker( |
| 169 blink::WebPermissionType type, |
| 170 const std::string& origin, |
| 171 blink::WebPermissionStatus status, |
| 172 int worker_thread_id, |
| 173 const base::Callback<void(blink::WebPermissionStatus)>& callback) { |
| 174 GetPermissionServicePtr()->GetNextPermissionChange( |
| 175 GetPermissionName(type), |
| 176 origin, |
| 177 GetPermissionStatus(status), |
| 178 base::Bind(&PermissionDispatcher::OnPermissionChangedForWorker, |
| 179 base::Unretained(this), |
| 180 worker_thread_id, |
| 181 callback)); |
| 182 } |
| 183 |
| 184 // static |
| 185 void PermissionDispatcher::RunCallbackOnWorkerThread( |
| 186 blink::WebPermissionQueryCallback* callback, |
| 187 scoped_ptr<blink::WebPermissionStatus> status) { |
| 188 callback->onSuccess(status.release()); |
| 189 delete callback; |
| 190 } |
| 191 |
| 192 PermissionServicePtr& PermissionDispatcher::GetPermissionServicePtr() { |
| 193 if (!permission_service_.get()) |
| 194 service_registry_->ConnectToRemoteService(&permission_service_); |
| 195 return permission_service_; |
| 196 } |
| 197 |
98 void PermissionDispatcher::QueryPermissionInternal( | 198 void PermissionDispatcher::QueryPermissionInternal( |
99 blink::WebPermissionType type, | 199 blink::WebPermissionType type, |
100 const std::string& origin, | 200 const std::string& origin, |
101 blink::WebPermissionQueryCallback* callback, | 201 blink::WebPermissionQueryCallback* callback, |
102 int worker_thread_id) { | 202 int worker_thread_id) { |
103 // We need to save the |callback| in an IDMap so if |this| gets deleted, the | 203 // 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 | 204 // callback will not leak. In the case of |this| gets deleted, the |
105 // |permission_service_| pipe will be destroyed too so OnQueryPermission will | 205 // |permission_service_| pipe will be destroyed too so OnQueryPermission will |
106 // not be called. | 206 // not be called. |
107 int request_id = pending_callbacks_.Add( | 207 int request_id = pending_callbacks_.Add( |
108 new CallbackInformation(callback, worker_thread_id)); | 208 new CallbackInformation(callback, worker_thread_id)); |
109 if (!permission_service_.get()) | 209 GetPermissionServicePtr()->HasPermission( |
110 service_registry_->ConnectToRemoteService(&permission_service_); | |
111 permission_service_->HasPermission( | |
112 GetPermissionName(type), | 210 GetPermissionName(type), |
113 origin, | 211 origin, |
114 base::Bind(&PermissionDispatcher::OnQueryPermission, | 212 base::Bind(&PermissionDispatcher::OnQueryPermission, |
115 base::Unretained(this), | 213 base::Unretained(this), |
116 request_id)); | 214 request_id)); |
117 } | 215 } |
118 | 216 |
119 void PermissionDispatcher::OnQueryPermission(int request_id, | 217 void PermissionDispatcher::OnQueryPermission(int request_id, |
120 PermissionStatus result) { | 218 PermissionStatus result) { |
121 CallbackInformation* callback_information = | 219 CallbackInformation* callback_information = |
122 pending_callbacks_.Lookup(request_id); | 220 pending_callbacks_.Lookup(request_id); |
123 DCHECK(callback_information && callback_information->callback()); | 221 DCHECK(callback_information && callback_information->callback()); |
124 scoped_ptr<blink::WebPermissionStatus> status( | 222 scoped_ptr<blink::WebPermissionStatus> status( |
125 new blink::WebPermissionStatus(GetWebPermissionStatus(result))); | 223 new blink::WebPermissionStatus(GetWebPermissionStatus(result))); |
126 | 224 |
127 if (callback_information->worker_thread_id() != kNoWorkerThread) { | 225 if (callback_information->worker_thread_id() != kNoWorkerThread) { |
128 blink::WebPermissionQueryCallback* callback = | 226 blink::WebPermissionQueryCallback* callback = |
129 callback_information->ReleaseCallback(); | 227 callback_information->ReleaseCallback(); |
130 int worker_thread_id = callback_information->worker_thread_id(); | 228 int worker_thread_id = callback_information->worker_thread_id(); |
131 pending_callbacks_.Remove(request_id); | 229 pending_callbacks_.Remove(request_id); |
132 | 230 |
133 // If the worker is no longer running, ::PostTask() will return false and | 231 // If the worker is no longer running, ::PostTask() will return false and |
134 // gracefully fail, destroying the callback too. | 232 // gracefully fail, destroying the callback too. |
135 WorkerTaskRunner::Instance()->PostTask( | 233 WorkerTaskRunner::Instance()->PostTask( |
136 worker_thread_id, | 234 worker_thread_id, |
137 base::Bind(&PermissionDispatcher::RunCallbackOnWorkerThread, | 235 base::Bind(&PermissionDispatcher::RunCallbackOnWorkerThread, |
138 base::Unretained(callback), | 236 base::Unretained(callback), |
139 base::Passed(&status))); | 237 base::Passed(&status))); |
140 return; | 238 return; |
141 } | 239 } |
142 | 240 |
143 callback_information->callback()->onSuccess(status.release()); | 241 callback_information->callback()->onSuccess(status.release()); |
144 pending_callbacks_.Remove(request_id); | 242 pending_callbacks_.Remove(request_id); |
145 } | 243 } |
146 | 244 |
147 // static | 245 void PermissionDispatcher::OnPermissionChanged( |
148 void PermissionDispatcher::RunCallbackOnWorkerThread( | 246 blink::WebPermissionType type, |
149 blink::WebPermissionQueryCallback* callback, | 247 const std::string& origin, |
150 scoped_ptr<blink::WebPermissionStatus> status) { | 248 WebPermissionObserver* observer, |
151 callback->onSuccess(status.release()); | 249 PermissionStatus status) { |
152 delete callback; | 250 if (!IsObserverRegistered(observer)) |
| 251 return; |
| 252 |
| 253 observer->permissionChanged(type, GetWebPermissionStatus(status)); |
| 254 |
| 255 GetNextPermissionChange(type, origin, observer, status); |
| 256 } |
| 257 |
| 258 void PermissionDispatcher::OnPermissionChangedForWorker( |
| 259 int worker_thread_id, |
| 260 const base::Callback<void(blink::WebPermissionStatus)>& callback, |
| 261 PermissionStatus status) { |
| 262 DCHECK(worker_thread_id != kNoWorkerThread); |
| 263 |
| 264 WorkerTaskRunner::Instance()->PostTask( |
| 265 worker_thread_id, base::Bind(callback, GetWebPermissionStatus(status))); |
| 266 } |
| 267 |
| 268 void PermissionDispatcher::GetNextPermissionChange( |
| 269 blink::WebPermissionType type, |
| 270 const std::string& origin, |
| 271 WebPermissionObserver* observer, |
| 272 PermissionStatus current_status) { |
| 273 GetPermissionServicePtr()->GetNextPermissionChange( |
| 274 GetPermissionName(type), |
| 275 origin, |
| 276 current_status, |
| 277 base::Bind(&PermissionDispatcher::OnPermissionChanged, |
| 278 base::Unretained(this), |
| 279 type, |
| 280 origin, |
| 281 base::Unretained(observer))); |
153 } | 282 } |
154 | 283 |
155 } // namespace content | 284 } // namespace content |
OLD | NEW |