Fixes Issues #5751 & #22631: NPObject identity

content/plugin/plugin_channel_base.h

 // Copyright (c) 2011 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_PLUGIN_PLUGIN_CHANNEL_BASE_H_
 #define CONTENT_PLUGIN_PLUGIN_CHANNEL_BASE_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/message_router.h"
 #include "content/plugin/npobject_base.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 
+#if defined(COMPILER_GCC)
+namespace __gnu_cxx {
+
+template<>
+struct hash<NPObject*> {
+  std::size_t operator()(NPObject* 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
+#endif // COMPILER
+
 // Encapsulates an IPC channel between a renderer and a plugin process.
 class PluginChannelBase : public IPC::Channel::Listener,
                           public IPC::Message::Sender,
                           public base::RefCountedThreadSafe<PluginChannelBase> {
  public:
 
   // WebPlugin[Delegate] call these on construction and destruction to setup
   // the routing and manage lifetime of this object.  This is also called by
   // NPObjectProxy and NPObjectStub.  However the latter don't control the
   // lifetime of this object (by passing true for npobject) because we don't
   // want a leak of an NPObject in a plugin to keep the channel around longer
   // than necessary.
   void AddRoute(int route_id, IPC::Channel::Listener* listener,
                 NPObjectBase* npobject);
   void RemoveRoute(int route_id);
 
+
+  void AddMappingForProxy(int route_id, NPObject* object);

[jam, 2011/05/20 23:22:22]

nit: we have several proxy/stub types.  can you call this NPObjectProxy instead
of Proxy, to be clear?

[Kelly Norton, 2011/05/23 15:02:56]

Done.

+  void RemoveMappingForProxy(int route_id);
+
+  void AddMappingForStub(int route_id, NPObject* object);
+  void RemoveMappingForStub(int route_id, NPObject* object);
+
+  NPObject* GetExistingProxy(int route_id);
+  int GetExistingRouteForStub(NPObject* npobject);
+
+
   // IPC::Message::Sender implementation:
   virtual bool Send(IPC::Message* msg);
 
   int peer_pid() { return peer_pid_; }
   IPC::ChannelHandle channel_handle() const { return channel_handle_; }
 
   // Returns the number of open plugin channels in this process.
   static int Count();
 
   // Returns a new route id.
@@ skipping 64 matching lines @@
   int peer_pid_;
 
   // true when in the middle of a RemoveRoute call
   bool in_remove_route_;
 
   // Keep track of all the registered NPObjects proxies/stubs so that when the
   // 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_;
+
   // 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.
   int in_unblock_dispatch_;
 
   // If true, sync messages will only be marked as unblocking if the channel is
   // in the middle of dispatching an unblocking message.
   // The plugin process wants to avoid setting the unblock flag on its sync
   // messages unless necessary, since it can potentially introduce reentrancy
   // into WebKit in ways that it doesn't expect (i.e. causing layout during
   // paint).  However to avoid deadlock, we must ensure that any message that's
   // sent as a result of a sync call from the renderer must unblock the
   // renderer.  We additionally have to do this for async messages from the
   // renderer that 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(PluginChannelBase);
 };
 
 #endif  // CONTENT_PLUGIN_PLUGIN_CHANNEL_BASE_H_