<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 36 matching lines @@
 
 namespace {
 
 // Events.
 const char kEventExit[] = "exit";
 const char kEventLoadAbort[] = "loadabort";
 const char kEventLoadCommit[] = "loadcommit";
 const char kEventLoadRedirect[] = "loadredirect";
 const char kEventLoadStart[] = "loadstart";
 const char kEventLoadStop[] = "loadstop";
+const char kEventRequestPermission[] = "permissionrequest";
 const char kEventResponsive[] = "responsive";
 const char kEventSizeChanged[] = "sizechanged";
 const char kEventUnresponsive[] = "unresponsive";
 
 // Parameters/properties on events.
 const char kIsTopLevel[] = "isTopLevel";
 const char kNewURL[] = "newUrl";
 const char kNewHeight[] = "newHeight";
 const char kNewWidth[] = "newWidth";
 const char kOldURL[] = "oldUrl";
 const char kOldHeight[] = "oldHeight";
 const char kOldWidth[] = "oldWidth";
 const char kPartition[] = "partition";
+const char kPermission[] = "permission";
+const char kPermissionTypeMedia[] = "media";
 const char kPersistPrefix[] = "persist:";
 const char kProcessId[] = "processId";
 const char kReason[] = "reason";
+const char kRequestId[] = "request_id";
 const char kSrc[] = "src";
 const char kURL[] = "url";
 
 // Error messages.
 const char kErrorAlreadyNavigated[] =
     "The object has already navigated, so its partition cannot be changed.";
 const char kErrorInvalidPartition[] =
     "Invalid partition attribute.";
 
 static std::string TerminationStatusToString(base::TerminationStatus status) {
@@ skipping 588 matching lines @@
 void BrowserPlugin::LoadAbort(const GURL& url,
                               bool is_top_level,
                               const std::string& type) {
   std::map<std::string, base::Value*> props;
   props[kURL] = base::Value::CreateStringValue(url.spec());
   props[kIsTopLevel] = base::Value::CreateBooleanValue(is_top_level);
   props[kReason] = base::Value::CreateStringValue(type);
   TriggerEvent(kEventLoadAbort, &props);
 }
 
+void BrowserPlugin::RequestMediaAccess(int request_id,
+                                       const GURL& security_origin) {
+  size_t num_listeners = GetNumberOfEventListeners(kEventRequestPermission);
+  if (!num_listeners) {
+    // Automatically deny the request if there are no event listeners for
+    // permissionrequest.
+    RespondMediaAccess(request_id, false /* allow */);
+    return;
+  }
+  DCHECK(media_access_pending_counts_.find(request_id) ==
+         media_access_pending_counts_.end());
+  media_access_pending_counts_[request_id] = num_listeners;
+
+  std::map<std::string, base::Value*> props;
+  props[kPermission] = base::Value::CreateStringValue(kPermissionTypeMedia);
+  props[kRequestId] = base::Value::CreateIntegerValue(request_id);
+  props[kURL] = base::Value::CreateStringValue(security_origin.spec());
+  TriggerEvent(kEventRequestPermission, &props);
+}
+
+size_t BrowserPlugin::GetNumberOfEventListeners(const std::string& event_name) {
+  if (!container())
+    return 0;
+
+  WebKit::WebNode parent = container()->element().parentNode();
+  if (!parent.isNull() && parent.isShadowRoot()) {
+    WebKit::WebElement shadow_host = parent.shadowHost();
+    if (!shadow_host.isNull()) {
+      return shadow_host.numberOfEventListeners(
+          WebKit::WebString::fromUTF8(event_name));
+    }
+  }
+  return 0;
+}
+
 void BrowserPlugin::LoadRedirect(const GURL& old_url,
                                  const GURL& new_url,
                                  bool is_top_level) {
   std::map<std::string, base::Value*> props;
   props[kOldURL] = base::Value::CreateStringValue(old_url.spec());
   props[kNewURL] = base::Value::CreateStringValue(new_url.spec());
   props[kIsTopLevel] = base::Value::CreateBooleanValue(is_top_level);
   TriggerEvent(kEventLoadRedirect, &props);
 }
 
@@ skipping 33 matching lines @@
 }
 
 void BrowserPlugin::SetAcceptTouchEvents(bool accept) {
   if (container()) {
     container()->requestTouchEventType(accept ?
         WebKit::WebPluginContainer::TouchEventRequestTypeRaw :
         WebKit::WebPluginContainer::TouchEventRequestTypeNone);
   }
 }
 
+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) {
+  MediaAccessPendingCountsMap::iterator iter =
+      media_access_pending_counts_.find(request_id);
+  if (iter == media_access_pending_counts_.end())
+    return;
+  DCHECK(iter->second > 0);
+  // If there were n listeners registered for media access permissionrequest, we
+  // require n allow() calls to allow the request.
+  // TODO(lazyboy): Figure out a way to track that each listener calls allow()
+  // at least once. Right now we only check for total number of allow() calls,
+  // which means a single listener calling allow() enough/multiple times can
+  // incorrectly allow the request.

[Charlie Reis, 2012/12/17 22:28:09]

Yeah, that's no good.  Ideally there would be some way to match up the responses
to the functions we handed out, like keeping a reference to each allow/deny
function.  An unforgeable ID (e.g., in the function's closure) would also be
sufficient.  I don't know how we can get TriggerEvent to hand out a different
version of the function to each listener, though.

We may need some advice on this, since it's an important aspect of the API if we
stick with this design.  Not sure I'm comfortable leaving it as a TODO without a
plan for how to fix it.

+  if (!allow || iter->second == 1) {
+    media_access_pending_counts_.erase(iter);
+    RespondMediaAccess(request_id, allow);
+  } else {
+    iter->second--;
+  }
+}
+
 WebKit::WebPluginContainer* BrowserPlugin::container() const {
   return container_;
 }
 
 bool BrowserPlugin::initialize(WebPluginContainer* container) {
   container_ = container;
   return true;
 }
 
 void BrowserPlugin::destroy() {
@@ skipping 271 matching lines @@
                                                  void* notify_data) {
 }
 
 void BrowserPlugin::didFailLoadingFrameRequest(
     const WebKit::WebURL& url,
     void* notify_data,
     const WebKit::WebURLError& error) {
 }
 
 }  // namespace content