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 "chrome/browser/permissions/permission_manager.h" | 5 #include "chrome/browser/permissions/permission_manager.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/callback.h" | 10 #include "base/callback.h" |
11 #include "base/memory/ptr_util.h" | 11 #include "base/memory/ptr_util.h" |
12 #include "build/build_config.h" | 12 #include "build/build_config.h" |
13 #include "chrome/browser/background_sync/background_sync_permission_context.h" | 13 #include "chrome/browser/background_sync/background_sync_permission_context.h" |
14 #include "chrome/browser/content_settings/host_content_settings_map_factory.h" | 14 #include "chrome/browser/content_settings/host_content_settings_map_factory.h" |
15 #include "chrome/browser/media/midi_permission_context.h" | 15 #include "chrome/browser/media/midi_permission_context.h" |
16 #include "chrome/browser/media/webrtc/media_stream_device_permission_context.h" | 16 #include "chrome/browser/media/webrtc/media_stream_device_permission_context.h" |
17 #include "chrome/browser/notifications/notification_permission_context.h" | 17 #include "chrome/browser/notifications/notification_permission_context.h" |
18 #include "chrome/browser/permissions/permission_context_base.h" | 18 #include "chrome/browser/permissions/permission_context_base.h" |
19 #include "chrome/browser/permissions/permission_manager_factory.h" | 19 #include "chrome/browser/permissions/permission_manager_factory.h" |
20 #include "chrome/browser/permissions/permission_request_id.h" | 20 #include "chrome/browser/permissions/permission_request_id.h" |
21 #include "chrome/browser/permissions/permission_result.h" | |
21 #include "chrome/browser/permissions/permission_uma_util.h" | 22 #include "chrome/browser/permissions/permission_uma_util.h" |
22 #include "chrome/browser/profiles/profile.h" | 23 #include "chrome/browser/profiles/profile.h" |
23 #include "chrome/browser/storage/durable_storage_permission_context.h" | 24 #include "chrome/browser/storage/durable_storage_permission_context.h" |
24 #include "chrome/browser/tab_contents/tab_util.h" | 25 #include "chrome/browser/tab_contents/tab_util.h" |
25 #include "chrome/common/features.h" | 26 #include "chrome/common/features.h" |
26 #include "components/content_settings/core/browser/host_content_settings_map.h" | 27 #include "components/content_settings/core/browser/host_content_settings_map.h" |
27 #include "content/public/browser/browser_thread.h" | 28 #include "content/public/browser/browser_thread.h" |
28 #include "content/public/browser/permission_type.h" | 29 #include "content/public/browser/permission_type.h" |
29 #include "content/public/browser/render_frame_host.h" | 30 #include "content/public/browser/render_frame_host.h" |
30 #include "content/public/browser/render_process_host.h" | 31 #include "content/public/browser/render_process_host.h" |
(...skipping 16 matching lines...) Expand all Loading... | |
47 | 48 |
48 using blink::mojom::PermissionStatus; | 49 using blink::mojom::PermissionStatus; |
49 using content::PermissionType; | 50 using content::PermissionType; |
50 | 51 |
51 namespace { | 52 namespace { |
52 | 53 |
53 // Helper method to convert ContentSetting to PermissionStatus. | 54 // Helper method to convert ContentSetting to PermissionStatus. |
54 PermissionStatus ContentSettingToPermissionStatus(ContentSetting setting) { | 55 PermissionStatus ContentSettingToPermissionStatus(ContentSetting setting) { |
55 switch (setting) { | 56 switch (setting) { |
56 case CONTENT_SETTING_ALLOW: | 57 case CONTENT_SETTING_ALLOW: |
57 case CONTENT_SETTING_SESSION_ONLY: | |
58 return PermissionStatus::GRANTED; | 58 return PermissionStatus::GRANTED; |
59 case CONTENT_SETTING_BLOCK: | 59 case CONTENT_SETTING_BLOCK: |
60 return PermissionStatus::DENIED; | 60 return PermissionStatus::DENIED; |
61 case CONTENT_SETTING_ASK: | 61 case CONTENT_SETTING_ASK: |
62 return PermissionStatus::ASK; | 62 return PermissionStatus::ASK; |
63 case CONTENT_SETTING_SESSION_ONLY: | |
63 case CONTENT_SETTING_DETECT_IMPORTANT_CONTENT: | 64 case CONTENT_SETTING_DETECT_IMPORTANT_CONTENT: |
64 case CONTENT_SETTING_DEFAULT: | 65 case CONTENT_SETTING_DEFAULT: |
65 case CONTENT_SETTING_NUM_SETTINGS: | 66 case CONTENT_SETTING_NUM_SETTINGS: |
66 break; | 67 break; |
67 } | 68 } |
68 | 69 |
69 NOTREACHED(); | 70 NOTREACHED(); |
70 return PermissionStatus::DENIED; | 71 return PermissionStatus::DENIED; |
71 } | 72 } |
72 | 73 |
73 // Wrap a callback taking a PermissionStatus to pass it as a callback taking a | |
74 // ContentSetting. | |
75 void ContentSettingToPermissionStatusCallbackWrapper( | |
76 const base::Callback<void(PermissionStatus)>& callback, | |
77 ContentSetting setting) { | |
78 callback.Run(ContentSettingToPermissionStatus(setting)); | |
79 } | |
80 | |
81 // Helper method to convert PermissionType to ContentSettingType. | 74 // Helper method to convert PermissionType to ContentSettingType. |
82 ContentSettingsType PermissionTypeToContentSetting(PermissionType permission) { | 75 ContentSettingsType PermissionTypeToContentSetting(PermissionType permission) { |
83 switch (permission) { | 76 switch (permission) { |
84 case PermissionType::MIDI: | 77 case PermissionType::MIDI: |
85 return CONTENT_SETTINGS_TYPE_MIDI; | 78 return CONTENT_SETTINGS_TYPE_MIDI; |
86 case PermissionType::MIDI_SYSEX: | 79 case PermissionType::MIDI_SYSEX: |
87 return CONTENT_SETTINGS_TYPE_MIDI_SYSEX; | 80 return CONTENT_SETTINGS_TYPE_MIDI_SYSEX; |
88 case PermissionType::PUSH_MESSAGING: | 81 case PermissionType::PUSH_MESSAGING: |
89 return CONTENT_SETTINGS_TYPE_PUSH_MESSAGING; | 82 return CONTENT_SETTINGS_TYPE_PUSH_MESSAGING; |
90 case PermissionType::NOTIFICATIONS: | 83 case PermissionType::NOTIFICATIONS: |
(...skipping 20 matching lines...) Expand all Loading... | |
111 case PermissionType::NUM: | 104 case PermissionType::NUM: |
112 // This will hit the NOTREACHED below. | 105 // This will hit the NOTREACHED below. |
113 break; | 106 break; |
114 } | 107 } |
115 | 108 |
116 NOTREACHED() << "Unknown content setting for permission " | 109 NOTREACHED() << "Unknown content setting for permission " |
117 << static_cast<int>(permission); | 110 << static_cast<int>(permission); |
118 return CONTENT_SETTINGS_TYPE_DEFAULT; | 111 return CONTENT_SETTINGS_TYPE_DEFAULT; |
119 } | 112 } |
120 | 113 |
121 // Returns whether the permission has a constant PermissionStatus value (i.e. | 114 // Returns whether the permission has a constant ContentSetting value (i.e. |
122 // always approved or always denied) | 115 // always approved or always denied) |
123 // The ContentSettingsTypes for which true is returned will also return nullptr | 116 // The ContentSettingsTypes for which true is returned will also return nullptr |
124 // in PermissionManager::GetPermissionContext since they don't have a context. | 117 // in PermissionManager::GetPermissionContext since they don't have a context. |
125 bool IsConstantPermission(ContentSettingsType type) { | 118 bool IsConstantPermission(ContentSettingsType type) { |
126 return type == CONTENT_SETTINGS_TYPE_MIDI; | 119 return type == CONTENT_SETTINGS_TYPE_MIDI; |
127 } | 120 } |
128 | 121 |
129 void PermissionRequestResponseCallbackWrapper( | 122 void SubscriptionCallbackWrapper( |
130 const base::Callback<void(PermissionStatus)>& callback, | 123 const base::Callback<void(PermissionStatus)>& callback, |
131 const std::vector<PermissionStatus>& vector) { | 124 ContentSetting content_setting) { |
132 DCHECK_EQ(vector.size(), 1ul); | 125 callback.Run(ContentSettingToPermissionStatus(content_setting)); |
126 } | |
127 | |
128 void PermissionStatusCallbackWrapper( | |
129 const base::Callback<void(PermissionStatus)>& callback, | |
130 const std::vector<ContentSetting>& vector) { | |
131 DCHECK_EQ(1ul, vector.size()); | |
132 callback.Run(ContentSettingToPermissionStatus(vector[0])); | |
133 } | |
134 | |
135 void PermissionStatusVectorCallbackWrapper( | |
136 const base::Callback<void(const std::vector<PermissionStatus>&)>& callback, | |
137 const std::vector<ContentSetting>& content_settings) { | |
138 std::vector<PermissionStatus> permission_statuses; | |
139 std::transform(content_settings.begin(), content_settings.end(), | |
140 back_inserter(permission_statuses), | |
141 ContentSettingToPermissionStatus); | |
142 callback.Run(permission_statuses); | |
143 } | |
144 | |
145 void ContentSettingCallbackWraper( | |
146 const base::Callback<void(ContentSetting)>& callback, | |
147 const std::vector<ContentSetting>& vector) { | |
148 DCHECK_EQ(1ul, vector.size()); | |
133 callback.Run(vector[0]); | 149 callback.Run(vector[0]); |
134 } | 150 } |
135 | 151 |
136 // Function used for handling permission types which do not change their | 152 // Function used for handling permission types which do not change their |
137 // value i.e. they are always approved or always denied etc. | 153 // value i.e. they are always approved or always denied etc. |
138 // CONTENT_SETTING_DEFAULT is returned if the permission needs further handling. | 154 // CONTENT_SETTING_DEFAULT is returned if the permission needs further handling. |
139 // This function should only be called when IsConstantPermission has returned | 155 // This function should only be called when IsConstantPermission has returned |
140 // true for the PermissionType. | 156 // true for the PermissionType. |
141 blink::mojom::PermissionStatus GetPermissionStatusForConstantPermission( | 157 ContentSetting GetContentSettingForConstantPermission( |
142 ContentSettingsType type) { | 158 ContentSettingsType type) { |
143 DCHECK(IsConstantPermission(type)); | 159 DCHECK(IsConstantPermission(type)); |
144 switch (type) { | 160 switch (type) { |
145 case CONTENT_SETTINGS_TYPE_MIDI: | 161 case CONTENT_SETTINGS_TYPE_MIDI: |
146 return PermissionStatus::GRANTED; | 162 return CONTENT_SETTING_ALLOW; |
147 default: | 163 default: |
148 return PermissionStatus::DENIED; | 164 return CONTENT_SETTING_BLOCK; |
149 } | 165 } |
150 } | 166 } |
151 | 167 |
152 } // anonymous namespace | 168 } // anonymous namespace |
153 | 169 |
154 class PermissionManager::PendingRequest { | 170 class PermissionManager::PendingRequest { |
155 public: | 171 public: |
156 PendingRequest( | 172 PendingRequest( |
157 content::RenderFrameHost* render_frame_host, | 173 content::RenderFrameHost* render_frame_host, |
158 const std::vector<ContentSettingsType>& permissions, | 174 const std::vector<ContentSettingsType>& permissions, |
159 const base::Callback<void(const std::vector<PermissionStatus>&)>& | 175 const base::Callback<void(const std::vector<ContentSetting>&)>& callback) |
160 callback) | |
161 : render_process_id_(render_frame_host->GetProcess()->GetID()), | 176 : render_process_id_(render_frame_host->GetProcess()->GetID()), |
162 render_frame_id_(render_frame_host->GetRoutingID()), | 177 render_frame_id_(render_frame_host->GetRoutingID()), |
163 callback_(callback), | 178 callback_(callback), |
164 permissions_(permissions), | 179 permissions_(permissions), |
165 results_(permissions.size(), PermissionStatus::DENIED), | 180 results_(permissions.size(), CONTENT_SETTING_BLOCK), |
166 remaining_results_(permissions.size()) {} | 181 remaining_results_(permissions.size()) {} |
167 | 182 |
168 void SetPermissionStatus(int permission_id, PermissionStatus status) { | 183 void SetContentSetting(int permission_id, ContentSetting content_setting) { |
169 DCHECK(!IsComplete()); | 184 DCHECK(!IsComplete()); |
170 | 185 |
171 results_[permission_id] = status; | 186 results_[permission_id] = content_setting; |
172 --remaining_results_; | 187 --remaining_results_; |
173 } | 188 } |
174 | 189 |
175 bool IsComplete() const { | 190 bool IsComplete() const { |
176 return remaining_results_ == 0; | 191 return remaining_results_ == 0; |
177 } | 192 } |
178 | 193 |
179 int render_process_id() const { return render_process_id_; } | 194 int render_process_id() const { return render_process_id_; } |
180 int render_frame_id() const { return render_frame_id_; } | 195 int render_frame_id() const { return render_frame_id_; } |
181 | 196 |
182 const base::Callback<void(const std::vector<PermissionStatus>&)> | 197 const base::Callback<void(const std::vector<ContentSetting>&)> callback() |
183 callback() const { | 198 const { |
184 return callback_; | 199 return callback_; |
185 } | 200 } |
186 | 201 |
187 std::vector<ContentSettingsType> permissions() const { | 202 std::vector<ContentSettingsType> permissions() const { |
188 return permissions_; | 203 return permissions_; |
189 } | 204 } |
190 | 205 |
191 std::vector<PermissionStatus> results() const { | 206 std::vector<ContentSetting> results() const { return results_; } |
192 return results_; | |
193 } | |
194 | 207 |
195 private: | 208 private: |
196 int render_process_id_; | 209 int render_process_id_; |
197 int render_frame_id_; | 210 int render_frame_id_; |
198 const base::Callback<void(const std::vector<PermissionStatus>&)> callback_; | 211 const base::Callback<void(const std::vector<ContentSetting>&)> callback_; |
199 std::vector<ContentSettingsType> permissions_; | 212 std::vector<ContentSettingsType> permissions_; |
200 std::vector<PermissionStatus> results_; | 213 std::vector<ContentSetting> results_; |
201 size_t remaining_results_; | 214 size_t remaining_results_; |
202 }; | 215 }; |
203 | 216 |
204 struct PermissionManager::Subscription { | 217 struct PermissionManager::Subscription { |
205 ContentSettingsType permission; | 218 ContentSettingsType permission; |
206 GURL requesting_origin; | 219 GURL requesting_origin; |
207 GURL embedding_origin; | 220 GURL embedding_origin; |
208 base::Callback<void(PermissionStatus)> callback; | 221 base::Callback<void(ContentSetting)> callback; |
209 PermissionStatus current_value; | 222 ContentSetting current_value; |
210 }; | 223 }; |
211 | 224 |
212 // static | 225 // static |
213 PermissionManager* PermissionManager::Get(Profile* profile) { | 226 PermissionManager* PermissionManager::Get(Profile* profile) { |
214 return PermissionManagerFactory::GetForProfile(profile); | 227 return PermissionManagerFactory::GetForProfile(profile); |
215 } | 228 } |
216 | 229 |
217 PermissionManager::PermissionManager(Profile* profile) | 230 PermissionManager::PermissionManager(Profile* profile) |
218 : profile_(profile), | 231 : profile_(profile), |
219 weak_ptr_factory_(this) { | 232 weak_ptr_factory_(this) { |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
256 if (!subscriptions_.IsEmpty()) | 269 if (!subscriptions_.IsEmpty()) |
257 HostContentSettingsMapFactory::GetForProfile(profile_) | 270 HostContentSettingsMapFactory::GetForProfile(profile_) |
258 ->RemoveObserver(this); | 271 ->RemoveObserver(this); |
259 } | 272 } |
260 | 273 |
261 int PermissionManager::RequestPermission( | 274 int PermissionManager::RequestPermission( |
262 ContentSettingsType content_settings_type, | 275 ContentSettingsType content_settings_type, |
263 content::RenderFrameHost* render_frame_host, | 276 content::RenderFrameHost* render_frame_host, |
264 const GURL& requesting_origin, | 277 const GURL& requesting_origin, |
265 bool user_gesture, | 278 bool user_gesture, |
266 const base::Callback<void(PermissionStatus)>& callback) { | 279 const base::Callback<void(ContentSetting)>& callback) { |
267 return RequestPermissions( | 280 return RequestPermissions( |
268 std::vector<ContentSettingsType>(1, content_settings_type), | 281 std::vector<ContentSettingsType>(1, content_settings_type), |
269 render_frame_host, requesting_origin, user_gesture, | 282 render_frame_host, requesting_origin, user_gesture, |
270 base::Bind(&PermissionRequestResponseCallbackWrapper, callback)); | 283 base::Bind(&ContentSettingCallbackWraper, callback)); |
271 } | 284 } |
272 | 285 |
273 int PermissionManager::RequestPermissions( | 286 int PermissionManager::RequestPermissions( |
274 const std::vector<ContentSettingsType>& permissions, | 287 const std::vector<ContentSettingsType>& permissions, |
275 content::RenderFrameHost* render_frame_host, | 288 content::RenderFrameHost* render_frame_host, |
276 const GURL& requesting_origin, | 289 const GURL& requesting_origin, |
277 bool user_gesture, | 290 bool user_gesture, |
278 const base::Callback<void(const std::vector<PermissionStatus>&)>& | 291 const base::Callback<void(const std::vector<ContentSetting>&)>& callback) { |
279 callback) { | |
280 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 292 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
281 if (permissions.empty()) { | 293 if (permissions.empty()) { |
282 callback.Run(std::vector<PermissionStatus>()); | 294 callback.Run(std::vector<ContentSetting>()); |
283 return kNoPendingOperation; | 295 return kNoPendingOperation; |
284 } | 296 } |
285 | 297 |
286 content::WebContents* web_contents = | 298 content::WebContents* web_contents = |
287 content::WebContents::FromRenderFrameHost(render_frame_host); | 299 content::WebContents::FromRenderFrameHost(render_frame_host); |
288 GURL embedding_origin = web_contents->GetLastCommittedURL().GetOrigin(); | 300 GURL embedding_origin = web_contents->GetLastCommittedURL().GetOrigin(); |
289 | 301 |
290 int request_id = pending_requests_.Add(base::MakeUnique<PendingRequest>( | 302 int request_id = pending_requests_.Add(base::MakeUnique<PendingRequest>( |
291 render_frame_host, permissions, callback)); | 303 render_frame_host, permissions, callback)); |
292 | 304 |
293 const PermissionRequestID request(render_frame_host, request_id); | 305 const PermissionRequestID request(render_frame_host, request_id); |
294 | 306 |
295 for (size_t i = 0; i < permissions.size(); ++i) { | 307 for (size_t i = 0; i < permissions.size(); ++i) { |
296 const ContentSettingsType permission = permissions[i]; | 308 const ContentSettingsType permission = permissions[i]; |
297 | 309 |
298 if (IsConstantPermission(permission) || !GetPermissionContext(permission)) { | 310 if (IsConstantPermission(permission) || !GetPermissionContext(permission)) { |
299 // Track permission request usages even for constant permissions. | 311 // Track permission request usages even for constant permissions. |
300 PermissionUmaUtil::PermissionRequested(permission, requesting_origin, | 312 PermissionUmaUtil::PermissionRequested(permission, requesting_origin, |
301 embedding_origin, profile_); | 313 embedding_origin, profile_); |
302 OnPermissionsRequestResponseStatus( | 314 OnPermissionsRequestResponseStatus( |
303 request_id, i, GetPermissionStatusForConstantPermission(permission)); | 315 request_id, i, GetContentSettingForConstantPermission(permission)); |
304 continue; | 316 continue; |
305 } | 317 } |
306 | 318 |
307 PermissionContextBase* context = GetPermissionContext(permission); | 319 PermissionContextBase* context = GetPermissionContext(permission); |
308 context->RequestPermission( | 320 context->RequestPermission( |
309 web_contents, request, requesting_origin, user_gesture, | 321 web_contents, request, requesting_origin, user_gesture, |
310 base::Bind(&ContentSettingToPermissionStatusCallbackWrapper, | 322 base::Bind(&PermissionManager::OnPermissionsRequestResponseStatus, |
311 base::Bind(&PermissionManager::OnPermissionsRequestResponseStatus, | 323 weak_ptr_factory_.GetWeakPtr(), request_id, i)); |
312 weak_ptr_factory_.GetWeakPtr(), request_id, i))); | |
313 } | 324 } |
314 | 325 |
315 // The request might have been resolved already. | 326 // The request might have been resolved already. |
316 if (!pending_requests_.Lookup(request_id)) | 327 if (!pending_requests_.Lookup(request_id)) |
317 return kNoPendingOperation; | 328 return kNoPendingOperation; |
318 | 329 |
319 return request_id; | 330 return request_id; |
320 } | 331 } |
321 | 332 |
322 PermissionStatus PermissionManager::GetPermissionStatus( | 333 PermissionResult PermissionManager::GetPermissionStatus( |
323 ContentSettingsType permission, | 334 ContentSettingsType permission, |
324 const GURL& requesting_origin, | 335 const GURL& requesting_origin, |
325 const GURL& embedding_origin) { | 336 const GURL& embedding_origin) { |
326 if (IsConstantPermission(permission)) | 337 if (IsConstantPermission(permission)) |
raymes
2017/03/01 01:25:03
nit: add {}
Timothy Loh
2017/03/01 04:08:55
Done.
| |
327 return GetPermissionStatusForConstantPermission(permission); | 338 return {GetContentSettingForConstantPermission(permission), |
339 PermissionStatusSource::UNSPECIFIED}; | |
raymes
2017/03/01 01:25:03
nit: Please use the constructor here
Timothy Loh
2017/03/01 04:08:55
Done.
| |
328 PermissionContextBase* context = GetPermissionContext(permission); | 340 PermissionContextBase* context = GetPermissionContext(permission); |
329 return ContentSettingToPermissionStatus( | 341 PermissionResult result = context->GetPermissionStatus( |
330 context | 342 requesting_origin.GetOrigin(), embedding_origin.GetOrigin()); |
331 ->GetPermissionStatus(requesting_origin.GetOrigin(), | 343 DCHECK(result.content_setting == CONTENT_SETTING_ALLOW || |
332 embedding_origin.GetOrigin()) | 344 result.content_setting == CONTENT_SETTING_ASK || |
333 .content_setting); | 345 result.content_setting == CONTENT_SETTING_BLOCK); |
346 return result; | |
334 } | 347 } |
335 | 348 |
336 int PermissionManager::RequestPermission( | 349 int PermissionManager::RequestPermission( |
337 PermissionType permission, | 350 PermissionType permission, |
338 content::RenderFrameHost* render_frame_host, | 351 content::RenderFrameHost* render_frame_host, |
339 const GURL& requesting_origin, | 352 const GURL& requesting_origin, |
340 bool user_gesture, | 353 bool user_gesture, |
341 const base::Callback<void(PermissionStatus)>& callback) { | 354 const base::Callback<void(PermissionStatus)>& callback) { |
342 ContentSettingsType content_settings_type = | 355 ContentSettingsType content_settings_type = |
343 PermissionTypeToContentSetting(permission); | 356 PermissionTypeToContentSetting(permission); |
344 return RequestPermissions( | 357 return RequestPermissions( |
345 std::vector<ContentSettingsType>(1, content_settings_type), | 358 std::vector<ContentSettingsType>(1, content_settings_type), |
346 render_frame_host, requesting_origin, user_gesture, | 359 render_frame_host, requesting_origin, user_gesture, |
347 base::Bind(&PermissionRequestResponseCallbackWrapper, callback)); | 360 base::Bind(&PermissionStatusCallbackWrapper, callback)); |
348 } | 361 } |
349 | 362 |
350 int PermissionManager::RequestPermissions( | 363 int PermissionManager::RequestPermissions( |
351 const std::vector<PermissionType>& permissions, | 364 const std::vector<PermissionType>& permissions, |
352 content::RenderFrameHost* render_frame_host, | 365 content::RenderFrameHost* render_frame_host, |
353 const GURL& requesting_origin, | 366 const GURL& requesting_origin, |
354 bool user_gesture, | 367 bool user_gesture, |
355 const base::Callback<void(const std::vector<PermissionStatus>&)>& | 368 const base::Callback<void(const std::vector<PermissionStatus>&)>& |
356 callback) { | 369 callback) { |
357 std::vector<ContentSettingsType> content_settings_types; | 370 std::vector<ContentSettingsType> content_settings_types; |
358 std::transform(permissions.begin(), permissions.end(), | 371 std::transform(permissions.begin(), permissions.end(), |
359 back_inserter(content_settings_types), | 372 back_inserter(content_settings_types), |
360 PermissionTypeToContentSetting); | 373 PermissionTypeToContentSetting); |
361 return RequestPermissions(content_settings_types, render_frame_host, | 374 return RequestPermissions( |
362 requesting_origin, user_gesture, callback); | 375 content_settings_types, render_frame_host, requesting_origin, |
376 user_gesture, | |
377 base::Bind(&PermissionStatusVectorCallbackWrapper, callback)); | |
363 } | 378 } |
364 | 379 |
365 PermissionContextBase* PermissionManager::GetPermissionContext( | 380 PermissionContextBase* PermissionManager::GetPermissionContext( |
366 ContentSettingsType type) { | 381 ContentSettingsType type) { |
367 const auto& it = permission_contexts_.find(type); | 382 const auto& it = permission_contexts_.find(type); |
368 return it == permission_contexts_.end() ? nullptr : it->second.get(); | 383 return it == permission_contexts_.end() ? nullptr : it->second.get(); |
369 } | 384 } |
370 | 385 |
371 void PermissionManager::OnPermissionsRequestResponseStatus( | 386 void PermissionManager::OnPermissionsRequestResponseStatus( |
372 int request_id, | 387 int request_id, |
373 int permission_id, | 388 int permission_id, |
374 PermissionStatus status) { | 389 ContentSetting content_setting) { |
375 PendingRequest* pending_request = pending_requests_.Lookup(request_id); | 390 PendingRequest* pending_request = pending_requests_.Lookup(request_id); |
376 pending_request->SetPermissionStatus(permission_id, status); | 391 pending_request->SetContentSetting(permission_id, content_setting); |
377 | 392 |
378 if (!pending_request->IsComplete()) | 393 if (!pending_request->IsComplete()) |
379 return; | 394 return; |
380 | 395 |
381 pending_request->callback().Run(pending_request->results()); | 396 pending_request->callback().Run(pending_request->results()); |
382 pending_requests_.Remove(request_id); | 397 pending_requests_.Remove(request_id); |
383 } | 398 } |
384 | 399 |
385 void PermissionManager::CancelPermissionRequest(int request_id) { | 400 void PermissionManager::CancelPermissionRequest(int request_id) { |
386 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 401 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
(...skipping 28 matching lines...) Expand all Loading... | |
415 | 430 |
416 context->ResetPermission(requesting_origin.GetOrigin(), | 431 context->ResetPermission(requesting_origin.GetOrigin(), |
417 embedding_origin.GetOrigin()); | 432 embedding_origin.GetOrigin()); |
418 } | 433 } |
419 | 434 |
420 PermissionStatus PermissionManager::GetPermissionStatus( | 435 PermissionStatus PermissionManager::GetPermissionStatus( |
421 PermissionType permission, | 436 PermissionType permission, |
422 const GURL& requesting_origin, | 437 const GURL& requesting_origin, |
423 const GURL& embedding_origin) { | 438 const GURL& embedding_origin) { |
424 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 439 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
425 return GetPermissionStatus(PermissionTypeToContentSetting(permission), | 440 return ContentSettingToPermissionStatus( |
426 requesting_origin, embedding_origin); | 441 GetPermissionStatus(PermissionTypeToContentSetting(permission), |
442 requesting_origin, embedding_origin) | |
443 .content_setting); | |
427 } | 444 } |
428 | 445 |
429 int PermissionManager::SubscribePermissionStatusChange( | 446 int PermissionManager::SubscribePermissionStatusChange( |
430 PermissionType permission, | 447 PermissionType permission, |
431 const GURL& requesting_origin, | 448 const GURL& requesting_origin, |
432 const GURL& embedding_origin, | 449 const GURL& embedding_origin, |
433 const base::Callback<void(PermissionStatus)>& callback) { | 450 const base::Callback<void(PermissionStatus)>& callback) { |
434 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 451 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
435 if (subscriptions_.IsEmpty()) | 452 if (subscriptions_.IsEmpty()) |
436 HostContentSettingsMapFactory::GetForProfile(profile_)->AddObserver(this); | 453 HostContentSettingsMapFactory::GetForProfile(profile_)->AddObserver(this); |
437 | 454 |
438 ContentSettingsType content_type = PermissionTypeToContentSetting(permission); | 455 ContentSettingsType content_type = PermissionTypeToContentSetting(permission); |
439 auto subscription = base::MakeUnique<Subscription>(); | 456 auto subscription = base::MakeUnique<Subscription>(); |
440 subscription->permission = content_type; | 457 subscription->permission = content_type; |
441 subscription->requesting_origin = requesting_origin; | 458 subscription->requesting_origin = requesting_origin; |
442 subscription->embedding_origin = embedding_origin; | 459 subscription->embedding_origin = embedding_origin; |
443 subscription->callback = callback; | 460 subscription->callback = base::Bind(&SubscriptionCallbackWrapper, callback); |
444 | 461 |
445 subscription->current_value = | 462 subscription->current_value = |
446 GetPermissionStatus(content_type, requesting_origin, embedding_origin); | 463 GetPermissionStatus(content_type, requesting_origin, embedding_origin) |
464 .content_setting; | |
447 | 465 |
448 return subscriptions_.Add(std::move(subscription)); | 466 return subscriptions_.Add(std::move(subscription)); |
449 } | 467 } |
450 | 468 |
451 void PermissionManager::UnsubscribePermissionStatusChange(int subscription_id) { | 469 void PermissionManager::UnsubscribePermissionStatusChange(int subscription_id) { |
452 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); | 470 DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
453 // Whether |subscription_id| is known will be checked by the Remove() call. | 471 // Whether |subscription_id| is known will be checked by the Remove() call. |
454 subscriptions_.Remove(subscription_id); | 472 subscriptions_.Remove(subscription_id); |
455 | 473 |
456 if (subscriptions_.IsEmpty()) | 474 if (subscriptions_.IsEmpty()) |
(...skipping 23 matching lines...) Expand all Loading... | |
480 if (subscription->permission != content_type) | 498 if (subscription->permission != content_type) |
481 continue; | 499 continue; |
482 | 500 |
483 if (primary_pattern.IsValid() && | 501 if (primary_pattern.IsValid() && |
484 !primary_pattern.Matches(subscription->requesting_origin)) | 502 !primary_pattern.Matches(subscription->requesting_origin)) |
485 continue; | 503 continue; |
486 if (secondary_pattern.IsValid() && | 504 if (secondary_pattern.IsValid() && |
487 !secondary_pattern.Matches(subscription->embedding_origin)) | 505 !secondary_pattern.Matches(subscription->embedding_origin)) |
488 continue; | 506 continue; |
489 | 507 |
490 PermissionStatus new_value = GetPermissionStatus( | 508 ContentSetting new_value = |
491 subscription->permission, subscription->requesting_origin, | 509 GetPermissionStatus(subscription->permission, |
492 subscription->embedding_origin); | 510 subscription->requesting_origin, |
511 subscription->embedding_origin) | |
512 .content_setting; | |
493 if (subscription->current_value == new_value) | 513 if (subscription->current_value == new_value) |
494 continue; | 514 continue; |
495 | 515 |
496 subscription->current_value = new_value; | 516 subscription->current_value = new_value; |
497 | 517 |
498 // Add the callback to |callbacks| which will be run after the loop to | 518 // Add the callback to |callbacks| which will be run after the loop to |
499 // prevent re-entrance issues. | 519 // prevent re-entrance issues. |
500 callbacks.push_back(base::Bind(subscription->callback, new_value)); | 520 callbacks.push_back(base::Bind(subscription->callback, new_value)); |
501 } | 521 } |
502 | 522 |
503 for (const auto& callback : callbacks) | 523 for (const auto& callback : callbacks) |
504 callback.Run(); | 524 callback.Run(); |
505 } | 525 } |
OLD | NEW |