<webview>: First stab at implementing media permission request for guests.

content/renderer/browser_plugin/browser_plugin.cc

 // Copyright (c) 2012 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 "content/renderer/browser_plugin/browser_plugin.h"
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 116 matching lines @@
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadAbort, OnLoadAbort)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadCommit, OnLoadCommit)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadRedirect, OnLoadRedirect)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadStart, OnLoadStart)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_LoadStop, OnLoadStop)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_SetCursor, OnSetCursor)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_ShouldAcceptTouchEvents,
                         OnShouldAcceptTouchEvents)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_UpdatedName, OnUpdatedName)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_UpdateRect, OnUpdateRect)
+    IPC_MESSAGE_HANDLER(BrowserPluginMsg_RequestMediaAccess,
+                        OnRequestMediaAccess)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BrowserPlugin::UpdateDOMAttribute(const std::string& attribute_name,
                                        const std::string& attribute_value) {
   if (!container())
     return;
 
@@ skipping 363 matching lines @@
     container()->requestTouchEventType(accept ?
         WebKit::WebPluginContainer::TouchEventRequestTypeRaw :
         WebKit::WebPluginContainer::TouchEventRequestTypeNone);
   }
 }
 
 void BrowserPlugin::OnUpdatedName(int instance_id, const std::string& name) {
   UpdateDOMAttribute(browser_plugin::kAttributeName, name);
 }
 
+void BrowserPlugin::OnRequestMediaAccess(int instance_id,
+                                         int request_id,
+                                         const GURL& security_origin) {
+  if (!HasEventListeners(browser_plugin::kEventRequestPermission)) {
+    // Automatically deny the request if there are no event listeners for
+    // permissionrequest.
+    RespondMediaAccess(request_id, false /* allow */);
+    return;
+  }
+  DCHECK(!media_access_pending_request_ids_.count(request_id));
+  media_access_pending_request_ids_.insert(request_id);
+
+  std::map<std::string, base::Value*> props;
+  props[browser_plugin::kPermission] =
+      base::Value::CreateStringValue(browser_plugin::kPermissionTypeMedia);
+  props[browser_plugin::kRequestId] =
+      base::Value::CreateIntegerValue(request_id);
+  props[browser_plugin::kURL] =
+      base::Value::CreateStringValue(security_origin.spec());
+  TriggerEvent(browser_plugin::kEventRequestPermission, &props);
+}
+
+bool BrowserPlugin::HasEventListeners(const std::string& event_name) {

[Fady Samuel, 2013/02/05 17:53:27]

I think you'd need the ancestor list here too, as a more general solution that
supports bubble.

[lazyboy, 2013/02/07 04:38:42]

Deferring it for now, added todo, I'll fix once we're happy with the rest.

+  if (!container())
+    return false;
+
+  WebKit::WebNode parent = container()->element().parentNode();
+  if (!parent.isNull() && parent.isShadowRoot()) {
+    WebKit::WebElement shadow_host = parent.shadowHost();
+    if (!shadow_host.isNull()) {
+      return shadow_host.hasEventListeners(
+          WebKit::WebString::fromUTF8(event_name));
+    }
+  }
+  return false;
+}
+
 void BrowserPlugin::OnUpdateRect(
     int instance_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
   bool use_new_damage_buffer = !backing_store_;
   BrowserPluginHostMsg_AutoSize_Params auto_size_params;
   BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
   // If we have a pending damage buffer, and the guest has begun to use the
   // damage buffer then we know the guest will no longer use the current
   // damage buffer. At this point, we drop the current damage buffer, and
   // mark the pending damage buffer as the current damage buffer.
@@ skipping 291 matching lines @@
   bool embedder_focused = false;
   if (render_view_)
     embedder_focused = render_view_->has_focus();
   return plugin_focused_ && embedder_focused;
 }
 
 WebKit::WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
+void BrowserPlugin::RespondMediaAccess(int request_id, bool allow) {
+  browser_plugin_manager()->Send(
+      new BrowserPluginHostMsg_AllowMediaAccess(render_view_->GetRoutingID(),
+                                                instance_id_,
+                                                request_id,
+                                                allow));
+}
+
+void BrowserPlugin::OnListenerCallMediaAccess(int request_id, bool allow) {
+  MediaAccessPendingRequestIds::iterator iter =
+      media_access_pending_request_ids_.find(request_id);
+  if (iter == media_access_pending_request_ids_.end())
+    return;
+  media_access_pending_request_ids_.erase(iter);
+  RespondMediaAccess(request_id, allow);
+}
+
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   container_ = container;
   container_->setWantsWheelEvents(true);
   ParseAttributes();
   return true;
 }
 
 void BrowserPlugin::EnableCompositing(bool enable) {
   if (compositing_enabled_ == enable)
     return;
@@ skipping 302 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content