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 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.
| |
129 // mojo service wants a value. Worse 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( | |
whywhat
2015/04/02 16:20:23
shouldn't you call the internal GetNextPermissionC
mlamouri (slow - plz ping)
2015/04/02 17:02:42
I see what you mean but they are slightly differen
| |
155 GetPermissionName(type), | |
156 origin, | |
157 // 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.
| |
158 // value. Worse 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))); | |
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 obs
| |
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 |