Refactor PPAPI proxy resource handling to maintain which host they came from,...

ppapi/proxy/plugin_var_tracker.h

 // Copyright (c) 2010 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 PPAPI_PROXY_PLUGIN_VAR_TRACKER_H_
 #define PPAPI_PROXY_PLUGIN_VAR_TRACKER_H_
 
 #include <map>
 #include <string>
 
@@ skipping 26 matching lines @@
 class PluginVarTracker {
  public:
   typedef int64_t VarID;
 
   // This uses the PluginDispatcher to identify the source of vars so that
   // the proper messages can be sent back. However, since all we need is the
   // ability to send messages, we can always use the Sender base class of
   // Dispatcher in this class, which makes it easy to unit test.
   typedef IPC::Channel::Sender Sender;
 
+  // Called by tests that want to specify a specific VarTracker. This allows
+  // them to use a unique one each time and avoids singletons sticking around
+  // across tests.
+  static void SetInstanceForTest(PluginVarTracker* tracker);
+
   // Returns the global var tracker for the plugin object.
   static PluginVarTracker* GetInstance();
 
   // Allocates a string and returns the ID of it. The refcount will be 1.
   VarID MakeString(const std::string& str);
   VarID MakeString(const char* str, uint32_t len);
 
   // Returns the string associated with the given string var. The var must be
   // of type string and must be valid or this function will crash.
   std::string GetString(const PP_Var& plugin_var) const;
@@ skipping 11 matching lines @@
   PP_Var ReceiveObjectPassRef(const PP_Var& var, Sender* channel);
 
   PP_Var TrackObjectWithNoReference(const PP_Var& host_var,
                                     Sender* channel);
   void StopTrackingObjectWithNoReference(const PP_Var& plugin_var);
 
   // Returns the host var for the corresponding plugin object var. The object
   // should be a VARTYPE_OBJECT
   PP_Var GetHostObject(const PP_Var& plugin_object) const;
 
+  // Like Release() but the var is identified by its host object ID (as
+  // returned by GetHostObject).
+  void ReleaseHostObject(Sender* sender, const PP_Var& host_object);
+
   // Retrieves the internal reference counts for testing. Returns 0 if we
   // know about the object but the corresponding value is 0, or -1 if the
   // given object ID isn't in our map.
   int GetRefCountForObject(const PP_Var& plugin_object);
   int GetTrackedWithNoReferenceCountForObject(const PP_Var& plugin_object);
 
  private:
   friend struct DefaultSingletonTraits<PluginVarTracker>;
-  friend class PluginVarTrackerTest;
+  friend class PluginProxyTest;
 
   // Represents a var as received from the host.
   struct HostVar {
     HostVar(Sender* s, int64_t i);
 
     bool operator<(const HostVar& other) const;
 
     // The host that sent us this object. This is used so we know how to send
     // back requests on this object.
     Sender* channel;
@@ skipping 57 matching lines @@
 
   // The last plugin object ID we've handed out. This must be unique for the
   // process.
   VarID last_plugin_object_id_;
 };
 
 }  // namespace proxy
 }  // namespace pp
 
 #endif  // PPAPI_PROXY_PLUGIN_VAR_TRACKER_H_