<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 80 matching lines @@
       persist_storage_(false),
       valid_partition_id_(true),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       size_changed_in_flight_(false),
       allocate_instance_id_sent_(false),
       browser_plugin_manager_(render_view->browser_plugin_manager()),
       current_nav_entry_index_(0),
       nav_entry_count_(0),
-      compositing_enabled_(false) {
+      compositing_enabled_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          weak_ptr_factory_(this)) {
   bindings_.reset(new BrowserPluginBindings(this));
 }
 
 BrowserPlugin::~BrowserPlugin() {
   // If the BrowserPlugin has never navigated then the browser process and
   // BrowserPluginManager don't know about it and so there is nothing to do
   // here.
   if (!navigate_src_sent_)
     return;
   browser_plugin_manager()->RemoveBrowserPlugin(instance_id_);
@@ skipping 10 matching lines @@
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestContentWindowReady,
                         OnGuestContentWindowReady)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestGone, OnGuestGone)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestResponsive, OnGuestResponsive)
     IPC_MESSAGE_HANDLER(BrowserPluginMsg_GuestUnresponsive, OnGuestUnresponsive)
     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_RequestPermission, OnRequestPermission)
     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_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 238 matching lines @@
       new BrowserPluginHostMsg_CreateGuest(render_view_routing_id_,
                                            instance_id_,
                                            create_guest_params));
 
   // Record that we sent a navigation request to the browser process.
   // Once this instance has navigated, the storage partition cannot be changed,
   // so this value is used for enforcing this.
   navigate_src_sent_ = true;
 }
 
+void BrowserPlugin::PopulateAncestorList() {
+  if (!container())
+    return;
+
+  WebKit::WebNode ancestor = container()->element();
+  // Escape the <webview> shim if this BrowserPlugin has one.
+  WebKit::WebElement shim = ancestor.shadowHost();
+  if (!shim.isNull())
+    ancestor = shim;
+  ancestors_.clear();
+  while (!ancestor.isNull()) {
+    ancestors_.push_back(ancestor);
+    ancestor = ancestor.parentNode();
+  }
+}
+
 void BrowserPlugin::OnAdvanceFocus(int instance_id, bool reverse) {
   DCHECK(render_view_);
   render_view_->GetWebView()->advanceFocus(reverse);
 }
 
 void BrowserPlugin::OnBuffersSwapped(int instance_id,
                                      const gfx::Size& size,
                                      std::string mailbox_name,
                                      int gpu_route_id,
                                      int gpu_host_id) {
@@ skipping 105 matching lines @@
   props[browser_plugin::kURL] = new base::StringValue(url.spec());
   props[browser_plugin::kIsTopLevel] = new base::FundamentalValue(is_top_level);
 
   TriggerEvent(browser_plugin::kEventLoadStart, &props);
 }
 
 void BrowserPlugin::OnLoadStop(int instance_id) {
   TriggerEvent(browser_plugin::kEventLoadStop, NULL);
 }
 
+void BrowserPlugin::OnRequestPermission(
+    int instance_id,
+    BrowserPluginPermissionType permission_type,
+    int request_id,
+    const base::DictionaryValue& request_info) {
+  if (permission_type == BrowserPluginPermissionTypeMedia)
+    RequestMediaPermission(request_id, request_info);
+}
+
 void BrowserPlugin::OnSetCursor(int instance_id, const WebCursor& cursor) {
   cursor_ = cursor;
 }
 
 void BrowserPlugin::OnShouldAcceptTouchEvents(int instance_id, bool accept) {
   if (container()) {
     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::RequestMediaPermission(
+    int request_id, const base::DictionaryValue& request_info) {
+  if (!HasEventListeners(browser_plugin::kEventRequestPermission)) {
+    // Automatically deny the request if there are no event listeners for
+    // permissionrequest.
+    AllowPermission(

[abarth-chromium, 2013/02/20 20:46:44]

It's confusing that you're using a function called "allow permission" to deny
the permission.

[lazyboy, 2013/02/20 22:09:36]

changed to "DecidePermission".

+        BrowserPluginPermissionTypeMedia, request_id, false /* allow */);

[abarth-chromium, 2013/02/20 20:46:44]

It's confusing that you're using a function called "AllowPermission" to deny the
permission.

[lazyboy, 2013/02/20 22:09:36]

ditto.

+    return;
+  }
+  DCHECK(!pending_permission_requests_.count(request_id));
+  pending_permission_requests_.insert(
+      std::make_pair(request_id,
+                     std::make_pair(request_id,
+                                    BrowserPluginPermissionTypeMedia)));
+
+  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);

[abarth-chromium, 2013/02/20 20:46:44]

Does this leak memory?  If not, where is this memory freed?

[lazyboy, 2013/02/20 22:09:36]

Seems we have this leak in all places where we're calling TriggerEvent, let me
fix that in a separate smaller patch.

[lazyboy, 2013/02/20 23:15:33]

I was wrong on this one, TriggerEvent() already frees up the memory by creating
DictionaryValue from |props|.

+
+  // Fill in the info provided by the browser.
+  for (DictionaryValue::Iterator iter(request_info); !iter.IsAtEnd();
+           iter.Advance()) {
+    props[iter.key()] = iter.value().DeepCopy();
+  }
+  TriggerEvent(browser_plugin::kEventRequestPermission, &props);
+}
+
+bool BrowserPlugin::HasEventListeners(const std::string& event_name) {
+  if (!container())
+    return false;
+
+  for (size_t i = 0; i < ancestors_.size(); ++i) {
+    if (ancestors_[i].hasEventListeners(
+            WebKit::WebString::fromUTF8(event_name))) {

[abarth-chromium, 2013/02/20 20:46:44]

It seems like we should create the WebString once instead of for each step in
the ancestor chain.

I think you're going to have to get rid of ancestors_ and walk the ancestor
chain directly here.

I'm not this it makes sense to check whether the ancestors have event listeners.
 That seems like a premature performance optimization.

[lazyboy, 2013/02/20 22:09:36]

Fixed WebString creation inside loop.
Removed ancestors_.

"I'm not this it makes sense to check whether the ancestors have event
listeners." ->
If we want to make this event bubble-able so any ancestor can also register for
this event; would we not have to do that?

+      return true;
+    }
+  }
+  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::OnRequestObjectGarbageCollected(int request_id) {
+  // Remove from alive objects.
+  std::map<int, AliveV8PermissionRequestItem*>::iterator iter =
+      alive_v8_permission_request_objects_.find(request_id);
+  if (iter != alive_v8_permission_request_objects_.end()) {
+    DCHECK(iter->second->first == request_id);
+    alive_v8_permission_request_objects_.erase(iter);
+  }
+
+  // If a decision has not been made for this request yet, deny it.
+  AllowPermissionIfRequestIsPending(request_id, false /*allow*/);
+}
+
+void BrowserPlugin::PersistRequestObject(
+    const NPVariant* request, const std::string& type, int id) {
+  DCHECK(alive_v8_permission_request_objects_.find(id) ==
+      alive_v8_permission_request_objects_.end());
+  if (alive_v8_permission_request_objects_.find(id) !=
+      alive_v8_permission_request_objects_.end()) {
+    return;
+  }

[abarth-chromium, 2013/02/20 20:46:44]

Why are you DCHECKing a condition and then handling it's negation?  Perhaps we
should use CHECK rather than DCHECK?

[lazyboy, 2013/02/20 22:09:36]

Changed to CHECK.

+  if (pending_permission_requests_.find(id) ==
+      pending_permission_requests_.end()) {
+    return;
+  }
+
+  v8::Persistent<v8::Value> weak_request =
+      v8::Persistent<v8::Value>::New(WebKit::WebBindings::toV8Value(request));
+
+  AliveV8PermissionRequestItem* new_item =
+      new std::pair<int, base::WeakPtr<BrowserPlugin> >(
+          id, weak_ptr_factory_.GetWeakPtr());
+
+  std::pair<std::map<int, AliveV8PermissionRequestItem*>::iterator, bool>
+      result = alive_v8_permission_request_objects_.insert(
+          std::make_pair(id, new_item));
+  CHECK(result.second);  // Inserted in the map.
+  AliveV8PermissionRequestItem* request_item = result.first->second;
+  weak_request.MakeWeak(request_item, WeakCallbackForPersistObject);
+}
+
+// static
+void BrowserPlugin::WeakCallbackForPersistObject(
+    v8::Persistent<v8::Value> object, void* param) {
+  v8::Persistent<v8::Object> persistent_object =
+      v8::Persistent<v8::Object>::Cast(object);
+
+  AliveV8PermissionRequestItem* item_ptr =
+      static_cast<AliveV8PermissionRequestItem*>(param);
+  int request_id = item_ptr->first;
+  base::WeakPtr<BrowserPlugin> plugin = item_ptr->second;
+  delete item_ptr;

[abarth-chromium, 2013/02/20 20:46:44]

I'm sad we need to manually manage memory like this.  Does Chromium really not
have better tools for memory management?

[lazyboy, 2013/02/20 22:09:36]

I'm not sure, the closest I could find was STLValueDeleter/STLElementDeleter in
stl_util.h, which doesn't fit our requirement here.

+
+  persistent_object.Dispose();
+  persistent_object.Clear();
+
+  if (plugin) {
+    // Asynchronously remove item from |alive_v8_permission_request_objects_|.
+    // Note that we are using weak pointer for the following PostTask, so we
+    // don't need to worry about BrowserPlugin going away.
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&BrowserPlugin::OnRequestObjectGarbageCollected,
+                   plugin, request_id));
+  }
+}
+
 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::AllowPermission(
+    BrowserPluginPermissionType permission_type, int request_id, bool allow) {
+  switch (permission_type) {
+    case BrowserPluginPermissionTypeMedia:
+      browser_plugin_manager()->Send(
+          new BrowserPluginHostMsg_AllowPermission(
+              render_view_->GetRoutingID(), instance_id_,
+              BrowserPluginPermissionTypeMedia, request_id, allow));
+      break;
+    case BrowserPluginPermissionTypeUnknown:
+    default:
+      LOG(INFO) << "Not a valid permission type";
+      break;

[abarth-chromium, 2013/02/20 20:46:44]

Should we have a DCHECK or a CHECK here?  How bad an error is this?

[lazyboy, 2013/02/20 22:09:36]

Added DCHECK.
This function is "supposed to" be accessible from web_view.js only, so an
incorrect permission_type is wrong, but should not be harmful; DCHECK is better
in these case, right?

+  }
+}
+
+void BrowserPlugin::AllowPermissionIfRequestIsPending(
+    int request_id, bool allow) {
+  PendingPermissionRequests::iterator iter =
+      pending_permission_requests_.find(request_id);
+  if (iter == pending_permission_requests_.end())
+    return;
+
+  int type = iter->second.second;
+  pending_permission_requests_.erase(iter);
+  AllowPermission(type, request_id, allow);
+}
+
+void BrowserPlugin::OnEmbedderDecidedPermission(int request_id, bool allow) {
+  AllowPermissionIfRequestIsPending(request_id, allow);
+}
+
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   container_ = container;
   container_->setWantsWheelEvents(true);
+  // This ancestor set is valid for the lifetime of BrowserPlugin as this object
+  // does not survive reparenting in the DOM tree.
+  PopulateAncestorList();
   ParseAttributes();
   return true;
 }
 
 void BrowserPlugin::EnableCompositing(bool enable) {
   if (compositing_enabled_ == enable)
     return;
 
   compositing_enabled_ = enable;
   if (enable) {
@@ skipping 303 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content