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_manager.h" | 5 #include "content/child/permissions/permission_dispatcher.h" |
6 | 6 |
7 #include "content/child/worker_task_runner.h" | 7 #include "content/child/worker_task_runner.h" |
8 #include "content/public/common/service_registry.h" | 8 #include "content/public/common/service_registry.h" |
9 #include "third_party/WebKit/public/platform/WebURL.h" | 9 #include "third_party/WebKit/public/platform/WebURL.h" |
10 | 10 |
11 namespace content { | 11 namespace content { |
12 | 12 |
13 namespace { | 13 namespace { |
14 | 14 |
15 PermissionName GetPermissionName(blink::WebPermissionType type) { | 15 PermissionName GetPermissionName(blink::WebPermissionType type) { |
(...skipping 25 matching lines...) Expand all Loading... |
41 } | 41 } |
42 | 42 |
43 NOTREACHED(); | 43 NOTREACHED(); |
44 return blink::WebPermissionStatusDenied; | 44 return blink::WebPermissionStatusDenied; |
45 } | 45 } |
46 | 46 |
47 const int kNoWorkerThread = 0; | 47 const int kNoWorkerThread = 0; |
48 | 48 |
49 } // anonymous namespace | 49 } // anonymous namespace |
50 | 50 |
51 PermissionManager::CallbackInformation::CallbackInformation( | 51 PermissionDispatcher::CallbackInformation::CallbackInformation( |
52 blink::WebPermissionQueryCallback* callback, | 52 blink::WebPermissionQueryCallback* callback, |
53 int worker_thread_id) | 53 int worker_thread_id) |
54 : callback_(callback), | 54 : callback_(callback), |
55 worker_thread_id_(worker_thread_id) { | 55 worker_thread_id_(worker_thread_id) { |
56 } | 56 } |
57 | 57 |
58 blink::WebPermissionQueryCallback* | 58 blink::WebPermissionQueryCallback* |
59 PermissionManager::CallbackInformation::callback() const { | 59 PermissionDispatcher::CallbackInformation::callback() const { |
60 return callback_.get(); | 60 return callback_.get(); |
61 } | 61 } |
62 | 62 |
63 int PermissionManager::CallbackInformation::worker_thread_id() const { | 63 int PermissionDispatcher::CallbackInformation::worker_thread_id() const { |
64 return worker_thread_id_; | 64 return worker_thread_id_; |
65 } | 65 } |
66 | 66 |
67 blink::WebPermissionQueryCallback* | 67 blink::WebPermissionQueryCallback* |
68 PermissionManager::CallbackInformation::ReleaseCallback() { | 68 PermissionDispatcher::CallbackInformation::ReleaseCallback() { |
69 return callback_.release(); | 69 return callback_.release(); |
70 } | 70 } |
71 | 71 |
72 PermissionManager::CallbackInformation::~CallbackInformation() { | 72 PermissionDispatcher::CallbackInformation::~CallbackInformation() { |
73 } | 73 } |
74 | 74 |
75 PermissionManager::PermissionManager(ServiceRegistry* service_registry) | 75 PermissionDispatcher::PermissionDispatcher(ServiceRegistry* service_registry) |
76 : service_registry_(service_registry) { | 76 : service_registry_(service_registry) { |
77 } | 77 } |
78 | 78 |
79 PermissionManager::~PermissionManager() { | 79 PermissionDispatcher::~PermissionDispatcher() { |
80 } | 80 } |
81 | 81 |
82 void PermissionManager::queryPermission( | 82 void PermissionDispatcher::queryPermission( |
83 blink::WebPermissionType type, | 83 blink::WebPermissionType type, |
84 const blink::WebURL& origin, | 84 const blink::WebURL& origin, |
85 blink::WebPermissionQueryCallback* callback) { | 85 blink::WebPermissionQueryCallback* callback) { |
86 QueryPermissionInternal( | 86 QueryPermissionInternal( |
87 type, origin.string().utf8(), callback, kNoWorkerThread); | 87 type, origin.string().utf8(), callback, kNoWorkerThread); |
88 } | 88 } |
89 | 89 |
90 void PermissionManager::QueryPermissionForWorker( | 90 void PermissionDispatcher::QueryPermissionForWorker( |
91 blink::WebPermissionType type, | 91 blink::WebPermissionType type, |
92 const std::string& origin, | 92 const std::string& origin, |
93 blink::WebPermissionQueryCallback* callback, | 93 blink::WebPermissionQueryCallback* callback, |
94 int worker_thread_id) { | 94 int worker_thread_id) { |
95 QueryPermissionInternal(type, origin, callback, worker_thread_id); | 95 QueryPermissionInternal(type, origin, callback, worker_thread_id); |
96 } | 96 } |
97 | 97 |
98 void PermissionManager::QueryPermissionInternal( | 98 void PermissionDispatcher::QueryPermissionInternal( |
99 blink::WebPermissionType type, | 99 blink::WebPermissionType type, |
100 const std::string& origin, | 100 const std::string& origin, |
101 blink::WebPermissionQueryCallback* callback, | 101 blink::WebPermissionQueryCallback* callback, |
102 int worker_thread_id) { | 102 int worker_thread_id) { |
103 // We need to save the |callback| in an IDMap so if |this| gets deleted, the | 103 // 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 | 104 // callback will not leak. In the case of |this| gets deleted, the |
105 // |permission_service_| pipe will be destroyed too so OnQueryPermission will | 105 // |permission_service_| pipe will be destroyed too so OnQueryPermission will |
106 // not be called. | 106 // not be called. |
107 int request_id = pending_callbacks_.Add( | 107 int request_id = pending_callbacks_.Add( |
108 new CallbackInformation(callback, worker_thread_id)); | 108 new CallbackInformation(callback, worker_thread_id)); |
109 if (!permission_service_.get()) | 109 if (!permission_service_.get()) |
110 service_registry_->ConnectToRemoteService(&permission_service_); | 110 service_registry_->ConnectToRemoteService(&permission_service_); |
111 permission_service_->HasPermission( | 111 permission_service_->HasPermission( |
112 GetPermissionName(type), | 112 GetPermissionName(type), |
113 origin, | 113 origin, |
114 base::Bind(&PermissionManager::OnQueryPermission, | 114 base::Bind(&PermissionDispatcher::OnQueryPermission, |
115 base::Unretained(this), | 115 base::Unretained(this), |
116 request_id)); | 116 request_id)); |
117 } | 117 } |
118 | 118 |
119 void PermissionManager::OnQueryPermission(int request_id, | 119 void PermissionDispatcher::OnQueryPermission(int request_id, |
120 PermissionStatus result) { | 120 PermissionStatus result) { |
121 CallbackInformation* callback_information = | 121 CallbackInformation* callback_information = |
122 pending_callbacks_.Lookup(request_id); | 122 pending_callbacks_.Lookup(request_id); |
123 DCHECK(callback_information && callback_information->callback()); | 123 DCHECK(callback_information && callback_information->callback()); |
124 scoped_ptr<blink::WebPermissionStatus> status( | 124 scoped_ptr<blink::WebPermissionStatus> status( |
125 new blink::WebPermissionStatus(GetWebPermissionStatus(result))); | 125 new blink::WebPermissionStatus(GetWebPermissionStatus(result))); |
126 | 126 |
127 if (callback_information->worker_thread_id() != kNoWorkerThread) { | 127 if (callback_information->worker_thread_id() != kNoWorkerThread) { |
128 blink::WebPermissionQueryCallback* callback = | 128 blink::WebPermissionQueryCallback* callback = |
129 callback_information->ReleaseCallback(); | 129 callback_information->ReleaseCallback(); |
130 int worker_thread_id = callback_information->worker_thread_id(); | 130 int worker_thread_id = callback_information->worker_thread_id(); |
131 pending_callbacks_.Remove(request_id); | 131 pending_callbacks_.Remove(request_id); |
132 | 132 |
133 // If the worker is no longer running, ::PostTask() will return false and | 133 // If the worker is no longer running, ::PostTask() will return false and |
134 // gracefully fail, destroying the callback too. | 134 // gracefully fail, destroying the callback too. |
135 WorkerTaskRunner::Instance()->PostTask( | 135 WorkerTaskRunner::Instance()->PostTask( |
136 worker_thread_id, | 136 worker_thread_id, |
137 base::Bind(&PermissionManager::RunCallbackOnWorkerThread, | 137 base::Bind(&PermissionDispatcher::RunCallbackOnWorkerThread, |
138 base::Unretained(callback), | 138 base::Unretained(callback), |
139 base::Passed(&status))); | 139 base::Passed(&status))); |
140 return; | 140 return; |
141 } | 141 } |
142 | 142 |
143 callback_information->callback()->onSuccess(status.release()); | 143 callback_information->callback()->onSuccess(status.release()); |
144 pending_callbacks_.Remove(request_id); | 144 pending_callbacks_.Remove(request_id); |
145 } | 145 } |
146 | 146 |
147 // static | 147 // static |
148 void PermissionManager::RunCallbackOnWorkerThread( | 148 void PermissionDispatcher::RunCallbackOnWorkerThread( |
149 blink::WebPermissionQueryCallback* callback, | 149 blink::WebPermissionQueryCallback* callback, |
150 scoped_ptr<blink::WebPermissionStatus> status) { | 150 scoped_ptr<blink::WebPermissionStatus> status) { |
151 callback->onSuccess(status.release()); | 151 callback->onSuccess(status.release()); |
152 delete callback; | 152 delete callback; |
153 } | 153 } |
154 | 154 |
155 } // namespace content | 155 } // namespace content |
OLD | NEW |