<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 381 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) {
+  if (!container())
+    return false;
+
+  // TODO(lazyboy): Fix before submitting: use ancestor list instead similar to
+  // window.open CL, so bubbling is supported.
+  WebKit::WebNode parent = container()->element().parentNode();
+  if (!parent.isNull() && !parent.shadowHost().isNull()) {
+    WebKit::WebElement shadow_host = parent.shadowHost();
+    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 227 matching lines @@
   // wrapper/shim (e.g. <webview> tag) should receive these events, and expose a
   // more appropriate (and stable) event to the consumers as part of the API.
   event.initCustomEvent(
       WebKit::WebString::fromUTF8(GetInternalEventName(event_name.c_str())),
       false, false,
       WebKit::WebSerializedScriptValue::serialize(
           v8::String::New(json_string.c_str(), json_string.size())));
   container()->element().dispatchEvent(event);
 }
 
+void BrowserPlugin::OnMediaRequestGarbageCollected(int request_id) {
+  // Remove from alive objects.
+  std::map<int, MediaAccessAliveV8RequestItem*>::iterator iter =
+      media_access_alive_v8_request_objects_.find(request_id);
+  if (iter != media_access_alive_v8_request_objects_.end()) {
+    MediaAccessAliveV8RequestItem* item = iter->second;
+    DCHECK(*item->first == request_id);
+    media_access_alive_v8_request_objects_.erase(iter);
+    delete item->first;
+  }
+
+  // If a decision has not been made for this request yet, deny it.
+  RespondMediaAccessIfPending(request_id, false /* allow */);
+}
+
+void BrowserPlugin::PersistRequestObject(const NPVariant* request, int id) {

[Fady Samuel, 2013/02/07 15:40:34]

Can we make this more general to allow for window.open's "window" object? Also
to allow for other permission types. This code to avoid referring directly to
media access as it will be used for other permissions and window.open.

[lazyboy, 2013/02/07 21:24:41]

We need a centralized id generation in that case, as discussed offline, we can
generalize when we have > 1 use case.

+  v8::Persistent<v8::Value> weak_request =
+      v8::Persistent<v8::Value>::New(WebKit::WebBindings::toV8Value(request));
+  int *new_request_id = new int(id);

[Fady Samuel, 2013/02/07 15:40:34]

why are you allocating memory on the heap here? We should be able to store ints
and pairs below directly in the map and pass a reference within the map to
MakeWeak.

[lazyboy, 2013/02/07 21:24:41]

I thought reference to map element is not guaranteed to stay the same if the map
was mutated, but the spec looks like it emphasizes that it should stay the same
(for associative containers) if I read this correctly:
http://gcc.gnu.org/onlinedocs/libstdc++/ext/lwg-active.html, search for "Modify
23.2.4 [associative.reqmts], p8:"
My assumption was based on std::vector probably.
I asked on IRC, no response yet I'll ask chromium-dev or awong@ to make sure.

+  std::pair<int*, BrowserPlugin*>* req =
+      new std::pair<int*, BrowserPlugin*>(
+          std::make_pair(new_request_id, this));
+  DCHECK(media_access_alive_v8_request_objects_.find(id) ==
+      media_access_alive_v8_request_objects_.end());
+  if (media_access_alive_v8_request_objects_.find(id) ==
+      media_access_alive_v8_request_objects_.end()) {
+    media_access_alive_v8_request_objects_[*new_request_id] = req;
+    weak_request.MakeWeak(req, WeakCallbackForPersistObject);
+  }
+}
+
+void BrowserPlugin::WeakCallbackForPersistObject(
+    v8::Persistent<v8::Value> object, void* param) {
+  v8::Persistent<v8::Object> persistent_object =
+      v8::Persistent<v8::Object>::Cast(object);
+
+  MediaAccessAliveV8RequestItem* item_ptr =
+      static_cast<std::pair<int*, BrowserPlugin*>*>(param);

[Fady Samuel, 2013/02/07 15:40:34]

We're leaking memory here. Seem my suggestion above. It should be possible to do
this without leaking memory or needing to explicitly allocate memory on the
heap. We can use a map to manage our memory for us.

[lazyboy, 2013/02/07 21:24:41]

See above, fixed hopefully.

+  int request_id = *(item_ptr->first);
+  BrowserPlugin* plugin = item_ptr->second;
+  plugin->OnMediaRequestGarbageCollected(request_id);
+
+  persistent_object.Dispose();
+}
+
 void BrowserPlugin::Back() {
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Go(render_view_routing_id_,
                                   instance_id_, -1));
 }
 
 void BrowserPlugin::Forward() {
   if (!navigate_src_sent_)
@@ skipping 50 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(

[Fady Samuel, 2013/02/07 15:40:34]

Given the review overhead for introducing new IPCs, I'm wondering if we can
generalize permission request IPCs?  BrowserPluginHostMsg_AllowPermissionRequest
perhaps?

This way we won't have to constantly request IPC audits as we add permissions.

[lazyboy, 2013/02/07 21:24:41]

This part should be straight forward.
Done.

+          render_view_->GetRoutingID(), instance_id_, request_id, allow));
+}
+
+void BrowserPlugin::RespondMediaAccessIfPending(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);
+}
+
+void BrowserPlugin::OnListenerCallMediaAccess(int request_id, bool allow) {
+  RespondMediaAccessIfPending(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