Add a new globals object for PPAPI tracking information.

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/host_globals.h"
 #include "webkit/plugins/ppapi/npobject_var.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/plugin_object.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
 
 using ppapi::NPObjectVar;
+using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::Var;
 using WebKit::WebBindings;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 const char kInvalidPluginValue[] = "Error: Plugin returned invalid value.";
@@ skipping 95 matching lines @@
   WebBindings::extractIdentifierData(id, string_value, int_value, is_string);
   if (is_string)
     return StringVar::StringToPPVar(module, string_value);
 
   return PP_MakeInt32(int_value);
 }
 
 PP_Var NPObjectToPPVar(PluginInstance* instance, NPObject* object) {
   DCHECK(object);
   scoped_refptr<NPObjectVar> object_var(
-      ResourceTracker::Get()->NPObjectVarForNPObject(instance->pp_instance(),
-                                                     object));
+      HostGlobals::Get()->host_resource_tracker()->NPObjectVarForNPObject(
+          instance->pp_instance(), object));
   if (!object_var) {  // No object for this module yet, make a new one.
     object_var = new NPObjectVar(instance->module()->pp_module(),
                                  instance->pp_instance(), object);
   }
   return object_var->GetPPVar();
 }
 
 // PPResultAndExceptionToNPResult ----------------------------------------------
 
 PPResultAndExceptionToNPResult::PPResultAndExceptionToNPResult(
     NPObject* object_var,
     NPVariant* np_result)
     : object_var_(object_var),
       np_result_(np_result),
       exception_(PP_MakeUndefined()),
       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_);
 
-  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(exception_);
+  PpapiGlobals::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_.
-  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(result);
+  PpapiGlobals::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 31 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();
+  ::ppapi::VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
   for (size_t i = 0; i < size_; i++)
     var_tracker->ReleaseVar(array_[i]);
 }
 
 // PPVarFromNPObject -----------------------------------------------------------
 
 PPVarFromNPObject::PPVarFromNPObject(PluginInstance* instance, NPObject* object)
     : var_(NPObjectToPPVar(instance, object)) {
 }
 
 PPVarFromNPObject::~PPVarFromNPObject() {
-  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(var_);
+  PpapiGlobals::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() {
-  ResourceTracker::Get()->GetVarTracker()->ReleaseVar(identifier_);
+  PpapiGlobals::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