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

ppapi/proxy/plugin_var_tracker.cc

 // 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.
 
 #include "ppapi/proxy/plugin_var_tracker.h"
 
 #include "base/ref_counted.h"
 #include "base/singleton.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/interface_id.h"
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
+// When non-NULL, this object overrides the VarTrackerSingleton.
+PluginVarTracker* var_tracker_override = NULL;
+
 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) {
   }
 
@@ skipping 29 matching lines @@
       ref_count(0),
       track_with_no_reference_count(0) {
 }
 
 PluginVarTracker::PluginVarTracker() : last_plugin_object_id_(0) {
 }
 
 PluginVarTracker::~PluginVarTracker() {
 }
 
+// static
+void PluginVarTracker::SetInstanceForTest(PluginVarTracker* tracker) {
+  var_tracker_override = tracker;
+}
+
+// static
 PluginVarTracker* PluginVarTracker::GetInstance() {
+  if (var_tracker_override)
+    return var_tracker_override;
   return Singleton<PluginVarTracker>::get();
 }
 
 PluginVarTracker::VarID PluginVarTracker::MakeString(const std::string& str) {
   RefCountedString* out = new RefCountedString(str);
   out->AddRef();
   return static_cast<VarID>(reinterpret_cast<intptr_t>(out));
 }
 
 PluginVarTracker::VarID PluginVarTracker::MakeString(const char* str,
@@ skipping 136 matching lines @@
   if (found == plugin_var_info_.end()) {
     NOTREACHED();
     return PP_MakeUndefined();
   }
   PP_Var ret;
   ret.type = PP_VARTYPE_OBJECT;
   ret.value.as_id = found->second.host_var.host_object_id;
   return ret;
 }
 
+void PluginVarTracker::ReleaseHostObject(Sender* sender,
+                                         const PP_Var& host_object) {
+  // Convert the host object to a normal var valid in the plugin.
+  DCHECK(host_object.type == PP_VARTYPE_OBJECT);
+  HostVarToPluginVarMap::iterator found = host_var_to_plugin_var_.find(
+      HostVar(sender, host_object.value.as_id));
+  if (found == host_var_to_plugin_var_.end()) {
+    NOTREACHED();
+    return;
+  }
+
+  // Now just release the object like normal.
+  PP_Var plugin_object;
+  plugin_object.type = PP_VARTYPE_OBJECT;
+  plugin_object.value.as_id = found->second;
+  Release(plugin_object);
+}
+
 int PluginVarTracker::GetRefCountForObject(const PP_Var& plugin_object) {
   PluginVarInfoMap::iterator found = plugin_var_info_.find(
       plugin_object.value.as_id);
   if (found == plugin_var_info_.end())
     return -1;
   return found->second.ref_count;
 }
 
 int PluginVarTracker::GetTrackedWithNoReferenceCountForObject(
     const PP_Var& plugin_object) {
@@ skipping 43 matching lines @@
 
   // Object ref counts are all zero, delete from both maps.
   DCHECK(host_var_to_plugin_var_.find(iter->second.host_var) !=
          host_var_to_plugin_var_.end());
   host_var_to_plugin_var_.erase(iter->second.host_var);
   plugin_var_info_.erase(iter);
 }
 
 }  // namesace proxy
 }  // namespace pp