| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/media/chrome_midi_permission_context.h" | |
| 6 | |
| 7 #include "base/prefs/pref_service.h" | |
| 8 #include "chrome/browser/content_settings/host_content_settings_map.h" | |
| 9 #include "chrome/browser/content_settings/permission_queue_controller.h" | |
| 10 #include "chrome/browser/content_settings/permission_request_id.h" | |
| 11 #include "chrome/browser/content_settings/tab_specific_content_settings.h" | |
| 12 #include "chrome/browser/profiles/profile.h" | |
| 13 #include "chrome/browser/tab_contents/tab_util.h" | |
| 14 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h" | |
| 15 #include "chrome/browser/ui/website_settings/permission_bubble_request.h" | |
| 16 #include "chrome/common/pref_names.h" | |
| 17 #include "content/public/browser/browser_thread.h" | |
| 18 #include "content/public/browser/web_contents.h" | |
| 19 #include "grit/generated_resources.h" | |
| 20 #include "grit/theme_resources.h" | |
| 21 #include "net/base/net_util.h" | |
| 22 #include "ui/base/l10n/l10n_util.h" | |
| 23 | |
| 24 class MidiPermissionRequest : public PermissionBubbleRequest { | |
| 25 public: | |
| 26 MidiPermissionRequest( | |
| 27 ChromeMidiPermissionContext* context, | |
| 28 const PermissionRequestID& id, | |
| 29 const GURL& requesting_frame, | |
| 30 bool user_gesture, | |
| 31 const std::string& display_languages, | |
| 32 const content::BrowserContext::MidiSysExPermissionCallback& callback); | |
| 33 virtual ~MidiPermissionRequest(); | |
| 34 | |
| 35 // PermissionBubbleDelegate: | |
| 36 virtual int GetIconID() const OVERRIDE; | |
| 37 virtual base::string16 GetMessageText() const OVERRIDE; | |
| 38 virtual base::string16 GetMessageTextFragment() const OVERRIDE; | |
| 39 virtual bool HasUserGesture() const OVERRIDE; | |
| 40 virtual GURL GetRequestingHostname() const OVERRIDE; | |
| 41 virtual void PermissionGranted() OVERRIDE; | |
| 42 virtual void PermissionDenied() OVERRIDE; | |
| 43 virtual void Cancelled() OVERRIDE; | |
| 44 virtual void RequestFinished() OVERRIDE; | |
| 45 | |
| 46 private: | |
| 47 ChromeMidiPermissionContext* context_; | |
| 48 const PermissionRequestID id_; | |
| 49 GURL requesting_frame_; | |
| 50 bool user_gesture_; | |
| 51 std::string display_languages_; | |
| 52 const content::BrowserContext::MidiSysExPermissionCallback& callback_; | |
| 53 bool is_finished_; | |
| 54 | |
| 55 DISALLOW_COPY_AND_ASSIGN(MidiPermissionRequest); | |
| 56 }; | |
| 57 | |
| 58 MidiPermissionRequest::MidiPermissionRequest( | |
| 59 ChromeMidiPermissionContext* context, | |
| 60 const PermissionRequestID& id, | |
| 61 const GURL& requesting_frame, | |
| 62 bool user_gesture, | |
| 63 const std::string& display_languages, | |
| 64 const content::BrowserContext::MidiSysExPermissionCallback& callback) | |
| 65 : context_(context), | |
| 66 id_(id), | |
| 67 requesting_frame_(requesting_frame), | |
| 68 user_gesture_(user_gesture), | |
| 69 display_languages_(display_languages), | |
| 70 callback_(callback), | |
| 71 is_finished_(false) {} | |
| 72 | |
| 73 MidiPermissionRequest::~MidiPermissionRequest() { | |
| 74 DCHECK(is_finished_); | |
| 75 } | |
| 76 | |
| 77 int MidiPermissionRequest::GetIconID() const { | |
| 78 return IDR_ALLOWED_MIDI_SYSEX; | |
| 79 } | |
| 80 | |
| 81 base::string16 MidiPermissionRequest::GetMessageText() const { | |
| 82 return l10n_util::GetStringFUTF16( | |
| 83 IDS_MIDI_SYSEX_INFOBAR_QUESTION, | |
| 84 net::FormatUrl(requesting_frame_.GetOrigin(), display_languages_)); | |
| 85 } | |
| 86 | |
| 87 base::string16 MidiPermissionRequest::GetMessageTextFragment() const { | |
| 88 return l10n_util::GetStringUTF16(IDS_MIDI_SYSEX_PERMISSION_FRAGMENT); | |
| 89 } | |
| 90 | |
| 91 bool MidiPermissionRequest::HasUserGesture() const { | |
| 92 return user_gesture_; | |
| 93 } | |
| 94 | |
| 95 GURL MidiPermissionRequest::GetRequestingHostname() const { | |
| 96 return requesting_frame_; | |
| 97 } | |
| 98 | |
| 99 void MidiPermissionRequest::PermissionGranted() { | |
| 100 context_->NotifyPermissionSet(id_, requesting_frame_, callback_, true); | |
| 101 } | |
| 102 | |
| 103 void MidiPermissionRequest::PermissionDenied() { | |
| 104 context_->NotifyPermissionSet(id_, requesting_frame_, callback_, false); | |
| 105 } | |
| 106 | |
| 107 void MidiPermissionRequest::Cancelled() { | |
| 108 } | |
| 109 | |
| 110 void MidiPermissionRequest::RequestFinished() { | |
| 111 is_finished_ = true; | |
| 112 // Deletes 'this'. | |
| 113 context_->RequestFinished(this); | |
| 114 } | |
| 115 | |
| 116 ChromeMidiPermissionContext::ChromeMidiPermissionContext(Profile* profile) | |
| 117 : profile_(profile), | |
| 118 shutting_down_(false) { | |
| 119 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 120 } | |
| 121 | |
| 122 ChromeMidiPermissionContext::~ChromeMidiPermissionContext() { | |
| 123 DCHECK(!permission_queue_controller_); | |
| 124 DCHECK(pending_requests_.empty()); | |
| 125 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 126 } | |
| 127 | |
| 128 void ChromeMidiPermissionContext::Shutdown() { | |
| 129 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 130 permission_queue_controller_.reset(); | |
| 131 shutting_down_ = true; | |
| 132 } | |
| 133 | |
| 134 void ChromeMidiPermissionContext::RequestMidiSysExPermission( | |
| 135 int render_process_id, | |
| 136 int render_view_id, | |
| 137 int bridge_id, | |
| 138 const GURL& requesting_frame, | |
| 139 bool user_gesture, | |
| 140 const content::BrowserContext::MidiSysExPermissionCallback& callback) { | |
| 141 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 142 DCHECK(!shutting_down_); | |
| 143 | |
| 144 // TODO(toyoshim): Support Extension's manifest declared permission. | |
| 145 // See http://crbug.com/266338. | |
| 146 | |
| 147 content::WebContents* web_contents = | |
| 148 tab_util::GetWebContentsByID(render_process_id, render_view_id); | |
| 149 | |
| 150 // The page doesn't exist any more. | |
| 151 if (!web_contents) | |
| 152 return; | |
| 153 | |
| 154 const PermissionRequestID id( | |
| 155 render_process_id, render_view_id, bridge_id, GURL()); | |
| 156 | |
| 157 GURL embedder = web_contents->GetURL(); | |
| 158 // |requesting_frame| can be empty and invalid when the frame is a local | |
| 159 // file. Here local files should be granted to show an infobar. | |
| 160 // Any user's action will not be stored to content settings data base. | |
| 161 if ((!requesting_frame.is_valid() && !requesting_frame.is_empty()) || | |
| 162 !embedder.is_valid()) { | |
| 163 LOG(WARNING) << "Attempt to use MIDI sysex from an invalid URL: " | |
| 164 << requesting_frame << "," << embedder | |
| 165 << " (Web MIDI is not supported in popups)"; | |
| 166 PermissionDecided(id, requesting_frame, embedder, callback, false); | |
| 167 return; | |
| 168 } | |
| 169 | |
| 170 DecidePermission(web_contents, id, requesting_frame, embedder, user_gesture, | |
| 171 callback); | |
| 172 } | |
| 173 | |
| 174 void ChromeMidiPermissionContext::CancelMidiSysExPermissionRequest( | |
| 175 int render_process_id, | |
| 176 int render_view_id, | |
| 177 int bridge_id, | |
| 178 const GURL& requesting_frame) { | |
| 179 CancelPendingInfobarRequest( | |
| 180 PermissionRequestID( | |
| 181 render_process_id, render_view_id, bridge_id, GURL())); | |
| 182 } | |
| 183 | |
| 184 void ChromeMidiPermissionContext::DecidePermission( | |
| 185 content::WebContents* web_contents, | |
| 186 const PermissionRequestID& id, | |
| 187 const GURL& requesting_frame, | |
| 188 const GURL& embedder, | |
| 189 bool user_gesture, | |
| 190 const content::BrowserContext::MidiSysExPermissionCallback& callback) { | |
| 191 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 192 | |
| 193 ContentSetting content_setting = | |
| 194 profile_->GetHostContentSettingsMap()->GetContentSetting( | |
| 195 requesting_frame, | |
| 196 embedder, | |
| 197 CONTENT_SETTINGS_TYPE_MIDI_SYSEX, | |
| 198 std::string()); | |
| 199 switch (content_setting) { | |
| 200 case CONTENT_SETTING_BLOCK: | |
| 201 PermissionDecided(id, requesting_frame, embedder, callback, false); | |
| 202 break; | |
| 203 case CONTENT_SETTING_ALLOW: | |
| 204 PermissionDecided(id, requesting_frame, embedder, callback, true); | |
| 205 break; | |
| 206 default: | |
| 207 if (PermissionBubbleManager::Enabled()) { | |
| 208 PermissionBubbleManager* bubble_manager = | |
| 209 PermissionBubbleManager::FromWebContents(web_contents); | |
| 210 if (bubble_manager) { | |
| 211 scoped_ptr<MidiPermissionRequest> request_ptr( | |
| 212 new MidiPermissionRequest( | |
| 213 this, id, requesting_frame, user_gesture, | |
| 214 profile_->GetPrefs()->GetString(prefs::kAcceptLanguages), | |
| 215 callback)); | |
| 216 MidiPermissionRequest* request = request_ptr.get(); | |
| 217 bool inserted = pending_requests_.add( | |
| 218 id.ToString(), request_ptr.Pass()).second; | |
| 219 DCHECK(inserted) << "Duplicate id " << id.ToString(); | |
| 220 bubble_manager->AddRequest(request); | |
| 221 } | |
| 222 return; | |
| 223 } | |
| 224 | |
| 225 // TODO(gbillock): Delete this and the infobar delegate when | |
| 226 // we're using only bubbles. crbug.com/337458 | |
| 227 GetQueueController()->CreateInfoBarRequest( | |
| 228 id, requesting_frame, embedder, std::string(), base::Bind( | |
| 229 &ChromeMidiPermissionContext::NotifyPermissionSet, | |
| 230 base::Unretained(this), id, requesting_frame, callback)); | |
| 231 } | |
| 232 } | |
| 233 | |
| 234 void ChromeMidiPermissionContext::PermissionDecided( | |
| 235 const PermissionRequestID& id, | |
| 236 const GURL& requesting_frame, | |
| 237 const GURL& embedder, | |
| 238 const content::BrowserContext::MidiSysExPermissionCallback& callback, | |
| 239 bool allowed) { | |
| 240 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 241 NotifyPermissionSet(id, requesting_frame, callback, allowed); | |
| 242 } | |
| 243 | |
| 244 void ChromeMidiPermissionContext::NotifyPermissionSet( | |
| 245 const PermissionRequestID& id, | |
| 246 const GURL& requesting_frame, | |
| 247 const content::BrowserContext::MidiSysExPermissionCallback& callback, | |
| 248 bool allowed) { | |
| 249 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 250 | |
| 251 TabSpecificContentSettings* content_settings = | |
| 252 TabSpecificContentSettings::Get(id.render_process_id(), | |
| 253 id.render_view_id()); | |
| 254 if (content_settings) { | |
| 255 if (allowed) | |
| 256 content_settings->OnMidiSysExAccessed(requesting_frame); | |
| 257 else | |
| 258 content_settings->OnMidiSysExAccessBlocked(requesting_frame); | |
| 259 } | |
| 260 | |
| 261 callback.Run(allowed); | |
| 262 } | |
| 263 | |
| 264 PermissionQueueController* ChromeMidiPermissionContext::GetQueueController() { | |
| 265 if (!permission_queue_controller_) { | |
| 266 permission_queue_controller_.reset( | |
| 267 new PermissionQueueController(profile_, | |
| 268 CONTENT_SETTINGS_TYPE_MIDI_SYSEX)); | |
| 269 } | |
| 270 return permission_queue_controller_.get(); | |
| 271 } | |
| 272 | |
| 273 void ChromeMidiPermissionContext::RequestFinished( | |
| 274 MidiPermissionRequest* request) { | |
| 275 base::ScopedPtrHashMap<std::string, MidiPermissionRequest>::iterator it; | |
| 276 for (it = pending_requests_.begin(); it != pending_requests_.end(); it++) { | |
| 277 if (it->second == request) { | |
| 278 pending_requests_.take_and_erase(it); | |
| 279 return; | |
| 280 } | |
| 281 } | |
| 282 | |
| 283 NOTREACHED() << "Missing request"; | |
| 284 } | |
| 285 | |
| 286 void ChromeMidiPermissionContext::CancelPendingInfobarRequest( | |
| 287 const PermissionRequestID& id) { | |
| 288 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | |
| 289 if (shutting_down_) | |
| 290 return; | |
| 291 | |
| 292 if (PermissionBubbleManager::Enabled()) { | |
| 293 MidiPermissionRequest* cancelling = pending_requests_.get(id.ToString()); | |
| 294 content::WebContents* web_contents = tab_util::GetWebContentsByID( | |
| 295 id.render_process_id(), id.render_view_id()); | |
| 296 if (cancelling != NULL && web_contents != NULL && | |
| 297 PermissionBubbleManager::FromWebContents(web_contents) != NULL) { | |
| 298 PermissionBubbleManager::FromWebContents(web_contents)-> | |
| 299 CancelRequest(cancelling); | |
| 300 } | |
| 301 return; | |
| 302 } | |
| 303 | |
| 304 GetQueueController()->CancelInfoBarRequest(id); | |
| 305 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 335993002:
Convert MIDI permission requests to use WebContents in preparation for switching the code to using … (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src