← Back to branch summary

~zaspire/oxide/push-messaging

« back to all changes in this revision

Viewing changes to shared/browser/permissions/oxide_permission_manager.cc

  • Committer: Chris Coulson
  • Date: 2015-06-10 22:36:42 UTC
  • mfrom: (1103.2.20 permissions)
  • Revision ID: chris.coulson@canonical.com-20150610223642-9cctvki80sb2ohuj
https://launchpad.net/bugs/1428754
Persist geolocation permission request decisions for the life of WebContext

Show diffs side-by-side

added added

removed removed

Lines of Context:
shared/browser/permissions/oxide_permission_manager.cc
22
22
#include "content/public/browser/permission_type.h"
23
23
#include "content/public/common/permission_status.mojom.h"
24
24
 
 
25
#include "shared/browser/oxide_browser_context.h"
 
26
 
25
27
#include "oxide_permission_request_dispatcher.h"
 
28
#include "oxide_permission_request_response.h"
 
29
#include "oxide_temporary_saved_permission_context.h"
26
30
 
27
31
namespace oxide {
28
32
 
29
33
namespace {
30
34
 
 
35
content::PermissionStatus ToPermissionStatus(
 
36
    PermissionRequestResponse response) {
 
37
  return response == PERMISSION_REQUEST_RESPONSE_ALLOW ?
 
38
      content::PERMISSION_STATUS_GRANTED :
 
39
      content::PERMISSION_STATUS_DENIED;
 
40
}
 
41
 
 
42
content::PermissionStatus ToPermissionStatus(
 
43
    TemporarySavedPermissionStatus status) {
 
44
  switch (status) {
 
45
    case TEMPORARY_SAVED_PERMISSION_STATUS_ALLOWED:
 
46
      return content::PERMISSION_STATUS_GRANTED;
 
47
    case TEMPORARY_SAVED_PERMISSION_STATUS_DENIED:
 
48
      return content::PERMISSION_STATUS_DENIED;
 
49
    case TEMPORARY_SAVED_PERMISSION_STATUS_ASK:
 
50
      return content::PERMISSION_STATUS_ASK;
 
51
    default:
 
52
      NOTREACHED();
 
53
      return content::PERMISSION_STATUS_DENIED;
 
54
  }
 
55
}
 
56
 
 
57
bool IsPermissionTypeSupported(content::PermissionType permission) {
 
58
  switch (permission) {
 
59
    case content::PermissionType::GEOLOCATION:
 
60
      return true;
 
61
    default:
 
62
      return false;
 
63
  }
 
64
}
 
65
 
 
66
TemporarySavedPermissionType ToTemporarySavedPermissionType(
 
67
    content::PermissionType permission) {
 
68
  switch (permission) {
 
69
    case content::PermissionType::GEOLOCATION:
 
70
      return TEMPORARY_SAVED_PERMISSION_TYPE_GEOLOCATION;
 
71
    default:
 
72
      NOTREACHED();
 
73
      // XXX(chrisccoulson): Perhaps we need __builtin_unreachable here?
 
74
      return static_cast<TemporarySavedPermissionType>(-1);
 
75
  }
 
76
}
 
77
 
 
78
TemporarySavedPermissionStatus ToTemporarySavedPermissionStatus(
 
79
    PermissionRequestResponse response) {
 
80
  DCHECK_NE(response, PERMISSION_REQUEST_RESPONSE_CANCEL);
 
81
  return response == PERMISSION_REQUEST_RESPONSE_ALLOW ?
 
82
      TEMPORARY_SAVED_PERMISSION_STATUS_ALLOWED :
 
83
      TEMPORARY_SAVED_PERMISSION_STATUS_DENIED;
 
84
}
 
85
 
31
86
void RespondToGeolocationPermissionRequest(
32
 
    const base::Callback<void(content::PermissionStatus)>& callback,
33
 
    content::PermissionStatus result) {
34
 
  if (result == content::PERMISSION_STATUS_GRANTED) {
 
87
    const PermissionRequestCallback& callback,
 
88
    PermissionRequestResponse response) {
 
89
  if (response == PERMISSION_REQUEST_RESPONSE_ALLOW) {
35
90
    content::GeolocationProvider::GetInstance()
36
91
        ->UserDidOptIntoLocationServices();
37
92
  }
38
 
  callback.Run(result);
39
 
}
40
 
 
41
 
base::Callback<void(content::PermissionStatus)> WrapCallback(
42
 
    const base::Callback<void(content::PermissionStatus)>& callback,
43
 
    content::PermissionType permission) {
 
93
  callback.Run(response);
 
94
}
 
95
 
 
96
void RespondToPermissionRequest(
 
97
    const base::Callback<void(content::PermissionStatus)>& callback,
 
98
    content::PermissionType permission,
 
99
    BrowserContext* context,
 
100
    const GURL& requesting_origin,
 
101
    const GURL& embedding_origin,
 
102
    PermissionRequestResponse response) {
 
103
  callback.Run(ToPermissionStatus(response));
 
104
 
 
105
  if (response == PERMISSION_REQUEST_RESPONSE_CANCEL) {
 
106
    return;
 
107
  }
 
108
 
 
109
  context->GetTemporarySavedPermissionContext()->SetPermissionStatus(
 
110
      ToTemporarySavedPermissionType(permission),
 
111
      requesting_origin,
 
112
      embedding_origin,
 
113
      ToTemporarySavedPermissionStatus(response));
 
114
}
 
115
 
 
116
const PermissionRequestCallback WrapCallback(
 
117
    const base::Callback<void(content::PermissionStatus)>& callback,
 
118
    content::PermissionType permission,
 
119
    BrowserContext* context,
 
120
    const GURL& requesting_origin,
 
121
    const GURL& embedding_origin) {
 
122
  const PermissionRequestCallback wrapped_callback =
 
123
      base::Bind(&RespondToPermissionRequest,
 
124
                 callback,
 
125
                 permission,
 
126
                 // The owner of PermissionRequestDispatcher keeps |context|
 
127
                 // alive. The request will be cancelled by
 
128
                 // PermissionRequestDispatcher when it is destroyed, so it's
 
129
                 // ok to not have a strong reference here
 
130
                 base::Unretained(context),
 
131
                 requesting_origin,
 
132
                 embedding_origin);
44
133
  switch (permission) {
45
134
    case content::PermissionType::GEOLOCATION:
46
 
      return base::Bind(&RespondToGeolocationPermissionRequest, callback);
 
135
      return base::Bind(&RespondToGeolocationPermissionRequest,
 
136
                        wrapped_callback);
47
137
    default:
48
 
      return callback;
 
138
      return wrapped_callback;
49
139
  }
50
140
}
51
141
 
62
152
    const GURL& requesting_origin,
63
153
    bool user_gesture,
64
154
    const base::Callback<void(content::PermissionStatus)>& callback) {
 
155
  if (!IsPermissionTypeSupported(permission)) {
 
156
    callback.Run(content::PERMISSION_STATUS_DENIED);
 
157
    return;
 
158
  }
 
159
 
 
160
  GURL embedding_origin = web_contents->GetLastCommittedURL().GetOrigin();
 
161
 
 
162
  TemporarySavedPermissionStatus status =
 
163
      context_->GetTemporarySavedPermissionContext()->GetPermissionStatus(
 
164
        ToTemporarySavedPermissionType(permission),
 
165
        requesting_origin,
 
166
        embedding_origin);
 
167
  if (status != TEMPORARY_SAVED_PERMISSION_STATUS_ASK) {
 
168
    callback.Run(ToPermissionStatus(status));
 
169
    return;
 
170
  }
 
171
 
65
172
  PermissionRequestDispatcher* dispatcher =
66
173
      PermissionRequestDispatcher::FromWebContents(web_contents);
67
174
  if (!dispatcher) {
69
176
    return;
70
177
  }
71
178
 
72
 
  dispatcher->RequestPermission(permission,
73
 
                                request_id,
74
 
                                requesting_origin,
75
 
                                WrapCallback(callback, permission));
 
179
  dispatcher->RequestPermission(
 
180
      permission,
 
181
      request_id,
 
182
      requesting_origin,
 
183
      WrapCallback(callback, permission, context_, requesting_origin,
 
184
                   embedding_origin));
76
185
}
77
186
 
78
187
void PermissionManager::CancelPermissionRequest(
95
204
    content::PermissionType permission,
96
205
    const GURL& requesting_origin,
97
206
    const GURL& embedding_origin) {
98
 
  return content::PERMISSION_STATUS_DENIED;
 
207
  if (!IsPermissionTypeSupported(permission)) {
 
208
    return content::PERMISSION_STATUS_DENIED;
 
209
  }
 
210
 
 
211
  return ToPermissionStatus(
 
212
      context_->GetTemporarySavedPermissionContext()->GetPermissionStatus(
 
213
        ToTemporarySavedPermissionType(permission),
 
214
        requesting_origin,
 
215
        embedding_origin));
99
216
}
100
217
 
101
218
void PermissionManager::ResetPermission(content::PermissionType permission,
102
219
                                        const GURL& requesting_origin,
103
 
                                        const GURL& embedding_origin) {}
 
220
                                        const GURL& embedding_origin) {
 
221
  NOTIMPLEMENTED();
 
222
}
104
223
 
105
224
void PermissionManager::RegisterPermissionUsage(
106
225
    content::PermissionType permission,
124
243
  subscriptions_.Remove(subscription_id);
125
244
}
126
245
 
127
 
PermissionManager::PermissionManager() {}
 
246
PermissionManager::PermissionManager(BrowserContext* context)
 
247
    : context_(context) {}
128
248
 
129
249
PermissionManager::~PermissionManager() {}
130
250