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

content/renderer/browser_plugin/browser_plugin.h

 // 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.
 
 #ifndef  CONTENT_RENDERER_BROWSER_PLUGIN_BROWSER_PLUGIN_H_
 #define  CONTENT_RENDERER_BROWSER_PLUGIN_BROWSER_PLUGIN_H_
 
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPlugin.h"
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 100 matching lines @@
   void Go(int relativeIndex);
   // Tells the BrowserPlugin to terminate the guest process.
   void TerminateGuest();
 
   // A request from Javascript has been made to stop the loading of the page.
   void Stop();
   // A request from Javascript has been made to reload the page.
   void Reload();
   // A request to enable hardware compositing.
   void EnableCompositing(bool enable);
+  // A request from shim to track lifetime of a js object related to media

[Charlie Reis, 2013/02/13 01:44:47]

nit: js -> JavaScript

Also, we probably shouldn't assume that the webview shim (in chrome) is the only
user of the BrowserPlugin.  Maybe shim -> content client?

Also, is this something specific to media, or should the comment be generalized?

[lazyboy, 2013/02/13 04:07:48]

Updated comment.
This is already generalized, stale comments corrected.

+  // access request object.
+  // This is used to clean up hanging media requests.
+  void PersistRequestObject(const NPVariant* request,
+                            const std::string& type,
+                            int id);
 
   // Returns true if |point| lies within the bounds of the plugin rectangle.
   // Not OK to use this function for making security-sensitive decision since it
   // can return false positives when the plugin has rotation transformation
   // applied.
   bool InBounds(const gfx::Point& point) const;
 
   gfx::Point ToLocalCoordinates(const gfx::Point& point) const;
+  // Called by browser plugin binding.
+  void OnEmbedderDecidedPermission(int request_id, bool allow);
+
 
   // WebKit::WebPlugin implementation.
   virtual WebKit::WebPluginContainer* container() const OVERRIDE;
   virtual bool initialize(WebKit::WebPluginContainer* container) OVERRIDE;
   virtual void destroy() OVERRIDE;
   virtual NPObject* scriptableObject() OVERRIDE;
   virtual bool supportsKeyboardFocus() const OVERRIDE;
   virtual bool canProcessDrag() const OVERRIDE;
   virtual void paint(
       WebKit::WebCanvas* canvas,
@@ skipping 28 matching lines @@
       const WebKit::WebURLError& error) OVERRIDE;
  private:
   friend class base::DeleteHelper<BrowserPlugin>;
   // Only the manager is allowed to create a BrowserPlugin.
   friend class BrowserPluginManagerImpl;
   friend class MockBrowserPluginManager;
 
   // For unit/integration tests.
   friend class MockBrowserPlugin;
 
+  enum PermissionRequestType {
+    INVALID = -1,
+    MEDIA
+  };
+
   // A BrowserPlugin object is a controller that represents an instance of a
   // browser plugin within the embedder renderer process. Each BrowserPlugin
   // within a process has a unique instance_id that is used to route messages
   // to it. It takes in a RenderViewImpl that it's associated with along
   // with the frame within which it lives and the initial attributes assigned
   // to it on creation.
   BrowserPlugin(
       RenderViewImpl* render_view,
       WebKit::WebFrame* frame,
       const WebKit::WebPluginParams& params);
@@ skipping 49 matching lines @@
   void GetDamageBufferWithSizeParams(
       BrowserPluginHostMsg_AutoSize_Params* auto_size_params,
       BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params);
 
   // Informs the guest of an updated autosize state.
   void UpdateGuestAutoSizeState(bool current_auto_size);
 
   // Informs the BrowserPlugin that guest has changed its size in autosize mode.
   void SizeChangedDueToAutoSize(const gfx::Size& old_view_size);
 
+  bool HasEventListeners(const std::string& event_name);
+
   // Indicates whether a damage buffer was used by the guest process for the
   // provided |params|.
   static bool UsesDamageBuffer(
       const BrowserPluginMsg_UpdateRect_Params& params);
 
   // Indicates whether the |pending_damage_buffer_| was used to copy over pixels
   // given the provided |params|.
   bool UsesPendingDamageBuffer(
       const BrowserPluginMsg_UpdateRect_Params& params);
 
   // Sets the instance ID of the BrowserPlugin and requests a guest from the
   // browser process.
   void SetInstanceID(int instance_id);
 
+  // Populates the ancestor set with the ancestors of the BrowserPlugin. A new
+  // BrowserPlugin gets created when we reparent the <object> node, so this
+  // set should always be valid.
+  void PopulateAncestorList();
+
+  // Requests media access permission from the embedder.
+  void RequestMediaPermission(int request_id,
+                                const base::DictionaryValue& request_info);
+  // Informs the BrowserPlugin that the guest's permission request has been
+  // allowed or denied by the embedder.
+  void RespondPermission(PermissionRequestType type,

[Charlie Reis, 2013/02/13 01:44:47]

This name (and the one below) feels awkward to me.  Should it be
RespondToPermissionRequest?  Or even something like AllowPermission?

[lazyboy, 2013/02/13 04:07:48]

Renamed to
AllowPermission
and
AllowPermissionIfRequestIsPending

+                         int request_id,
+                         bool allow);
+
+  void RespondPermissionIfPending(int request_id, bool allow);
+  void OnRequestObjectGarbageCollected(int request_id);
+  static void WeakCallbackForPersistObject(v8::Persistent<v8::Value> object,
+                                           void* param);
+
   // IPC message handlers.
   // Please keep in alphabetical order.
   void OnAdvanceFocus(int instance_id, bool reverse);
   void OnBuffersSwapped(int instance_id,
                         const gfx::Size& size,
                         std::string mailbox_name,
                         int gpu_route_id,
                         int gpu_host_id);
   void OnGuestContentWindowReady(int instance_id,
                                  int content_window_routing_id);
   void OnGuestGone(int instance_id, int process_id, int status);
   void OnGuestResponsive(int instance_id, int process_id);
   void OnGuestUnresponsive(int instance_id, int process_id);
   void OnLoadAbort(int instance_id,
                    const GURL& url,
                    bool is_top_level,
                    const std::string& type);
   void OnLoadCommit(int instance_id,
                     const BrowserPluginMsg_LoadCommit_Params& params);
   void OnLoadRedirect(int instance_id,
                       const GURL& old_url,
                       const GURL& new_url,
                       bool is_top_level);
   void OnLoadStart(int instance_id, const GURL& url, bool is_top_level);
   void OnLoadStop(int instance_id);
+  // Requests permission from the embedder.
+  void OnRequestPermission(int instance_id,
+                           const std::string& permission_type,
+                           int request_id,
+                           const base::DictionaryValue& request_info);
   void OnSetCursor(int instance_id, const WebCursor& cursor);
   void OnShouldAcceptTouchEvents(int instance_id, bool accept);
   void OnUpdatedName(int instance_id, const std::string& name);
   void OnUpdateRect(int instance_id,
                     const BrowserPluginMsg_UpdateRect_Params& params);
 
   int instance_id_;
   base::WeakPtr<RenderViewImpl> render_view_;
   // We cache the |render_view_|'s routing ID because we need it on destruction.
   // If the |render_view_| is destroyed before the BrowserPlugin is destroyed
@@ skipping 24 matching lines @@
   // Tracks the visibility of the browser plugin regardless of the whole
   // embedder RenderView's visibility.
   bool visible_;
 
   WebCursor cursor_;
 
   gfx::Size last_view_size_;
   bool size_changed_in_flight_;
   bool allocate_instance_id_sent_;
 
+  typedef std::map<int, std::pair<int, PermissionRequestType> >
+      PendingPermissionRequests;
+  PendingPermissionRequests pending_permission_requests_;
+
+  typedef std::pair<int, base::WeakPtr<BrowserPlugin> >
+      AliveV8PermissionRequestItem;
+  std::map<int, AliveV8PermissionRequestItem*>
+      alive_v8_permission_request_objects;
+
   // BrowserPlugin outlives RenderViewImpl in Chrome Apps and so we need to
   // store the BrowserPlugin's BrowserPluginManager in a member variable to
   // avoid accessing the RenderViewImpl.
   scoped_refptr<BrowserPluginManager> browser_plugin_manager_;
 
   // Important: Do not add more history state here.
   // We strongly discourage storing additional history state (such as page IDs)
   // in the embedder process, at the risk of having incorrect information that
   // can lead to broken back/forward logic in apps.
   // It's also important that this state does not get modified by any logic in
   // the embedder process. It should only be updated in response to navigation
   // events in the guest.  No assumptions should be made about how the index
   // will change after a navigation (e.g., for back, forward, or go), because
   // the changes are not always obvious.  For example, there is a maximum
   // number of entries and earlier ones will automatically be pruned.
   int current_nav_entry_index_;
   int nav_entry_count_;
 
   // Used for HW compositing.
   bool compositing_enabled_;
   scoped_refptr<BrowserPluginCompositingHelper> compositing_helper_;
 
+  // Weak factory used in v8 |MakeWeak| callback, since the v8 callback might
+  // get called after BrowserPlugin has been destroyed.
+  base::WeakPtrFactory<BrowserPlugin> weak_ptr_factory_;

[Charlie Reis, 2013/02/13 01:44:47]

Please have someone familiar with V8 review all this logic for the MakeWeak
callback, since I'm not knowledgable here.  Perhaps abarth?

[lazyboy, 2013/02/13 04:07:48]

Yes, my plan is to get this reviewed by abarth@ after you're happy with the CL.

+
+  // Set of ancestor nodes.
+  std::vector<WebKit::WebNode> ancestors_;
+
   DISALLOW_COPY_AND_ASSIGN(BrowserPlugin);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_BROWSER_PLUGIN_BROWSER_PLUGIN_H_