Proxy PPB_Var, fix o-o-p string var id tracking.

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>
 
+#include "base/memory/ref_counted.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/pp_var.h"
 
 struct PPB_Var;
 
 template<typename T> struct DefaultSingletonTraits;
 
 namespace pp {
 namespace proxy {
 
@@ skipping 23 matching lines @@
   // 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;
-
   // Returns a pointer to the given string if it exists, or NULL if the var
   // isn't a string var.
   const std::string* GetExistingString(const PP_Var& plugin_var) const;
 
   void AddRef(const PP_Var& plugin_var);
   void Release(const PP_Var& plugin_var);
 
   // Manages tracking for receiving a VARTYPE_OBJECT from the remote side
   // (either the plugin or the renderer) that has already had its reference
   // count incremented on behalf of the caller.
@@ skipping 18 matching lines @@
   // 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 PluginProxyTest;
 
+  class RefCountedString : public base::RefCounted<RefCountedString> {
+   public:
+    RefCountedString() {
+    }
+    RefCountedString(const std::string& str) : value_(str) {
+    }
+    RefCountedString(const char* data, size_t len)
+        : value_(data, len) {
+    }
+
+    const std::string& value() const { return value_; }
+
+   private:
+    std::string value_;
+
+    // Ensure only base::RefCounted can delete a RefCountedString.
+    friend void base::RefCounted<RefCountedString>::Release() const;
+    virtual ~RefCountedString() {}
+  };
+  typedef scoped_refptr<RefCountedString> RefCountedStringPtr;
+
   // Represents a var as received from the host.
   struct HostVar {
     HostVar(PluginDispatcher* d, int64_t i);
 
     bool operator<(const HostVar& other) const;
 
     // The dispatcher that sent us this object. This is used so we know how to
     // send back requests on this object.
     PluginDispatcher* dispatcher;
 
@@ skipping 47 matching lines @@
   void DeletePluginVarInfoIfNecessary(PluginVarInfoMap::iterator iter);
 
   // Tracks all information about plugin vars.
   PluginVarInfoMap plugin_var_info_;
 
   // Maps host vars to plugin vars. This allows us to know if we've previously
   // seen a host var and re-use the information.
   typedef std::map<HostVar, VarID> HostVarToPluginVarMap;
   HostVarToPluginVarMap host_var_to_plugin_var_;
 
-  // The last plugin object ID we've handed out. This must be unique for the
+  // Maps plugin var IDs to ref counted strings.
+  typedef std::map<VarID, RefCountedStringPtr> VarIDStringMap;
+  VarIDStringMap var_id_to_string_;
+
+  // The last plugin PP_Var ID we've handed out. This must be unique for the
   // process.
-  VarID last_plugin_object_id_;
+  VarID last_plugin_var_id_;
+
+  // Get a new Var ID and increment last_plugin_var_id_.
+  VarID GetNewVarID();
 };
 
 }  // namespace proxy
 }  // namespace pp
 
 #endif  // PPAPI_PROXY_PLUGIN_VAR_TRACKER_H_