Unify var tracking between webkit and the proxy.

webkit/plugins/ppapi/npapi_glue.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 "webkit/plugins/ppapi/npapi_glue.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/string_util.h"
 #include "webkit/plugins/ppapi/npobject_var.h"
@@ skipping 141 matching lines @@
       success_(false),
       checked_exception_(false) {
 }
 
 PPResultAndExceptionToNPResult::~PPResultAndExceptionToNPResult() {
   // The user should have called SetResult or CheckExceptionForNoResult
   // before letting this class go out of scope, or the exception will have
   // been lost.
   DCHECK(checked_exception_);
 
-  NPObjectVar::PluginReleasePPVar(exception_);
+  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(exception_);
 }
 
 // Call this with the return value of the PPAPI function. It will convert
 // the result to the NPVariant output parameter and pass any exception on to
 // the JS engine. It will update the success flag and return it.
 bool PPResultAndExceptionToNPResult::SetResult(PP_Var result) {
   DCHECK(!checked_exception_);  // Don't call more than once.
   DCHECK(np_result_);  // Should be expecting a result.
 
   checked_exception_ = true;
 
   if (has_exception()) {
     ThrowException();
     success_ = false;
   } else if (!PPVarToNPVariant(result, np_result_)) {
     WebBindings::setException(object_var_, kInvalidPluginValue);
     success_ = false;
   } else {
     success_ = true;
   }
 
   // No matter what happened, we need to release the reference to the
   // value passed in. On success, a reference to this value will be in
   // the np_result_.
-  ::ppapi::Var::PluginReleasePPVar(result);
+  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(result);
   return success_;
 }
 
 // Call this after calling a PPAPI function that could have set the
 // exception. It will pass the exception on to the JS engine and update
 // the success flag.
 //
 // The success flag will be returned.
 bool PPResultAndExceptionToNPResult::CheckExceptionForNoResult() {
   DCHECK(!checked_exception_);  // Don't call more than once.
@@ skipping 32 matching lines @@
     const NPVariant* variants)
     : size_(size) {
   if (size_ > 0) {
     array_.reset(new PP_Var[size_]);
     for (size_t i = 0; i < size_; i++)
       array_[i] = NPVariantToPPVar(instance, &variants[i]);
   }
 }
 
 PPVarArrayFromNPVariantArray::~PPVarArrayFromNPVariantArray() {
+  ::ppapi::VarTracker* var_tracker = ResourceTracker::Get()->GetVarTracker();
   for (size_t i = 0; i < size_; i++)
-    ::ppapi::Var::PluginReleasePPVar(array_[i]);
+    var_tracker->ReleaseVar(array_[i]);
 }
 
 // PPVarFromNPObject -----------------------------------------------------------
 
 PPVarFromNPObject::PPVarFromNPObject(PluginInstance* instance, NPObject* object)
     : var_(NPObjectToPPVar(instance, object)) {
 }
 
 PPVarFromNPObject::~PPVarFromNPObject() {
-  ::ppapi::Var::PluginReleasePPVar(var_);
+  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(var_);
 }
 
 // NPObjectAccessorWithIdentifier ----------------------------------------------
 
 NPObjectAccessorWithIdentifier::NPObjectAccessorWithIdentifier(
     NPObject* object,
     NPIdentifier identifier,
     bool allow_integer_identifier)
     : object_(PluginObject::FromNPObject(object)),
       identifier_(PP_MakeUndefined()) {
   if (object_) {
     identifier_ = NPIdentifierToPPVar(
         object_->instance()->module()->pp_module(), identifier);
     if (identifier_.type == PP_VARTYPE_INT32 && !allow_integer_identifier)
       identifier_.type = PP_VARTYPE_UNDEFINED;  // Mark it invalid.
   }
 }
 
 NPObjectAccessorWithIdentifier::~NPObjectAccessorWithIdentifier() {
-  ::ppapi::Var::PluginReleasePPVar(identifier_);
+  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(identifier_);
 }
 
 // TryCatch --------------------------------------------------------------------
 
 TryCatch::TryCatch(PP_Module module, PP_Var* exception)
     : pp_module_(module),
       has_exception_(exception && exception->type != PP_VARTYPE_UNDEFINED),
       exception_(exception) {
   WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
 }
@@ skipping 28 matching lines @@
   }
 }
 
 // static
 void TryCatch::Catch(void* self, const char* message) {
   static_cast<TryCatch*>(self)->SetException(message);
 }
 
 }  // namespace ppapi
 }  // namespace webkit