Track NPObject ownership by the originating plugins' NPP identifier. [4/6] (Chrome)

content/child/np_channel_base.h

 // Copyright 2013 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_CHILD_NP_CHANNEL_BASE_H_
 #define CONTENT_CHILD_NP_CHANNEL_BASE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 13 matching lines @@
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
 
 template<>
 struct hash<NPObject*> {
   std::size_t operator()(NPObject* const& ptr) const {
     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
   }
 };
 
+template<>
+struct hash<struct _NPP*> {
+  std::size_t operator()(struct _NPP* const& ptr) const {
+    return hash<size_t>()(reinterpret_cast<size_t>(ptr));
+  }
+};
+
 }  // namespace __gnu_cxx
 #elif defined(COMPILER_MSVC)
 namespace stdext {
 
 template<>
 inline size_t hash_value(NPObject* const& ptr) {
   return hash_value(reinterpret_cast<size_t>(ptr));
 }
 
 }  // namespace stdext
@@ skipping 10 matching lines @@
 
   // WebPlugin[Delegate] call these on construction and destruction to setup
   // the routing and manage lifetime of this object (they pass NULL for
   // npobject). These are also called by NPObjectProxy and NPObjectStub (which
   // pass themselves for npobject).  However the latter don't control the
   // lifetime of this object because we don't want a leak of an NPObject to
   // keep the channel around longer than necessary.
   void AddRoute(int route_id, IPC::Listener* listener, NPObjectBase* npobject);
   void RemoveRoute(int route_id);
 
-
   void AddMappingForNPObjectProxy(int route_id, NPObject* object);
   void RemoveMappingForNPObjectProxy(int route_id);
 
   void AddMappingForNPObjectStub(int route_id, NPObject* object);
   void RemoveMappingForNPObjectStub(int route_id, NPObject* object);
 
+  void AddMappingForNPObjectOwner(int route_id, struct _NPP* owner);
+  void SetDefaultNPObjectOwner(struct _NPP* owner);
+  void RemoveMappingForNPObjectOwner(int route_id);
+
   NPObject* GetExistingNPObjectProxy(int route_id);
   int GetExistingRouteForNPObjectStub(NPObject* npobject);
-
+  struct _NPP* GetExistingNPObjectOwner(int route_id);
+  int GetExistingRouteForNPObjectOwner(struct _NPP* owner);
 
   // IPC::Sender implementation:
   virtual bool Send(IPC::Message* msg) OVERRIDE;
 
   base::ProcessId peer_pid() { return channel_->peer_pid(); }
   IPC::ChannelHandle channel_handle() const { return channel_handle_; }
 
   // Returns the number of open NPObject channels in this process.
   static int Count();
 
@@ skipping 80 matching lines @@
   // channel is closed we can inform them.
   typedef base::hash_map<int, NPObjectBase*> ListenerMap;
   ListenerMap npobject_listeners_;
 
   typedef base::hash_map<int, NPObject*> ProxyMap;
   ProxyMap proxy_map_;
 
   typedef base::hash_map<NPObject*, int> StubMap;
   StubMap stub_map_;
 
+  typedef base::hash_map<struct _NPP*, int> OwnerToRouteMap;
+  OwnerToRouteMap owner_to_route_;
+
+  typedef base::hash_map<int, struct _NPP*> RouteToOwnerMap;
+  RouteToOwnerMap route_to_owner_;
+
+  // Used on the plugin side to represent any object received that does
+  // not belong to a plugin instance.
+  struct _NPP* default_owner_;
+
   // Used to implement message routing functionality to WebPlugin[Delegate]
   // objects
   MessageRouter router_;
 
   // A channel is invalid if it is disconnected as a result of a channel
   // error. This flag is used to indicate the same.
   bool channel_valid_;
 
   // Track whether we're dispatching a message with the unblock flag; works like
   // a refcount, 0 when we're not.
@@ skipping 10 matching lines @@
   // have the unblock flag set, since they could be followed by a sync message
   // that won't get dispatched until the call to the renderer is complete.
   bool send_unblocking_only_during_unblock_dispatch_;
 
   DISALLOW_COPY_AND_ASSIGN(NPChannelBase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_NP_CHANNEL_BASE_H_