1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/push_messaging/push_messaging_permission_context.h"
#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
#include "chrome/browser/notifications/notification_permission_context.h"
#include "chrome/browser/notifications/notification_permission_context_factory.h"
#include "chrome/browser/permissions/permission_request_id.h"
#include "chrome/browser/permissions/permission_uma_util.h"
#include "chrome/browser/profiles/profile.h"
#include "components/content_settings/core/browser/host_content_settings_map.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/permission_type.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/common/origin_util.h"
PushMessagingPermissionContext::PushMessagingPermissionContext(Profile* profile)
: PermissionContextBase(profile,
content::PermissionType::PUSH_MESSAGING,
CONTENT_SETTINGS_TYPE_PUSH_MESSAGING),
profile_(profile),
weak_factory_ui_thread_(this) {}
PushMessagingPermissionContext::~PushMessagingPermissionContext() {}
ContentSetting PushMessagingPermissionContext::GetPermissionStatus(
const GURL& requesting_origin,
const GURL& embedding_origin) const {
// It's possible for this to return CONTENT_SETTING_BLOCK in cases where
// HostContentSettingsMap::GetContentSetting returns CONTENT_SETTING_ALLOW.
// TODO(johnme): This is likely to break assumptions made elsewhere, so we
// should try to remove this quirk.
#if defined(ENABLE_NOTIFICATIONS)
if (requesting_origin != embedding_origin)
return CONTENT_SETTING_BLOCK;
ContentSetting push_content_setting =
PermissionContextBase::GetPermissionStatus(requesting_origin,
embedding_origin);
NotificationPermissionContext* notification_context =
NotificationPermissionContextFactory::GetForProfile(profile_);
DCHECK(notification_context);
ContentSetting notifications_permission =
notification_context->GetPermissionStatus(requesting_origin,
embedding_origin);
if (notifications_permission == CONTENT_SETTING_BLOCK ||
push_content_setting == CONTENT_SETTING_BLOCK) {
return CONTENT_SETTING_BLOCK;
}
if (notifications_permission == CONTENT_SETTING_ASK ||
push_content_setting == CONTENT_SETTING_ASK) {
return CONTENT_SETTING_ASK;
}
DCHECK_EQ(CONTENT_SETTING_ALLOW, notifications_permission);
DCHECK_EQ(CONTENT_SETTING_ALLOW, push_content_setting);
return CONTENT_SETTING_ALLOW;
#else
return CONTENT_SETTING_BLOCK;
#endif
}
// Unlike other permissions, push is decided by the following algorithm
// - You need to request it from a top level domain
// - You need to have notification permission granted.
// - You need to not have push permission explicitly blocked.
// - If those 3 things are true it is granted without prompting.
// This is done to avoid double prompting for notifications and push.
void PushMessagingPermissionContext::DecidePermission(
content::WebContents* web_contents,
const PermissionRequestID& id,
const GURL& requesting_origin,
const GURL& embedding_origin,
bool user_gesture,
const BrowserPermissionCallback& callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
#if defined(ENABLE_NOTIFICATIONS)
if (requesting_origin != embedding_origin) {
NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
false /* persist */, CONTENT_SETTING_BLOCK);
return;
}
NotificationPermissionContext* notification_context =
NotificationPermissionContextFactory::GetForProfile(profile_);
DCHECK(notification_context);
notification_context->RequestPermission(
web_contents, id, requesting_origin, user_gesture,
base::Bind(&PushMessagingPermissionContext::DecidePushPermission,
weak_factory_ui_thread_.GetWeakPtr(), id, requesting_origin,
embedding_origin, callback));
#else
NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
false /* persist */, CONTENT_SETTING_BLOCK);
#endif
}
bool PushMessagingPermissionContext::IsRestrictedToSecureOrigins() const {
return true;
}
void PushMessagingPermissionContext::DecidePushPermission(
const PermissionRequestID& id,
const GURL& requesting_origin,
const GURL& embedding_origin,
const BrowserPermissionCallback& callback,
ContentSetting notification_content_setting) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
ContentSetting push_content_setting =
HostContentSettingsMapFactory::GetForProfile(profile_)
->GetContentSettingAndMaybeUpdateLastUsage(
requesting_origin, embedding_origin, content_settings_type(),
std::string());
if (push_content_setting == CONTENT_SETTING_BLOCK) {
DVLOG(1) << "Push permission was explicitly blocked.";
PermissionUmaUtil::PermissionDenied(permission_type(), requesting_origin);
NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
true /* persist */, CONTENT_SETTING_BLOCK);
return;
}
if (notification_content_setting != CONTENT_SETTING_ALLOW) {
DVLOG(1) << "Notification permission has not been granted.";
NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
false /* persist */, notification_content_setting);
return;
}
PermissionUmaUtil::PermissionGranted(permission_type(), requesting_origin);
NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
true /* persist */, CONTENT_SETTING_ALLOW);
}
|
