Revert 106142 - Add a new globals object for PPAPI tracking information.

webkit/plugins/ppapi/resource_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 "webkit/plugins/ppapi/resource_tracker.h"
 
 #include <limits>
 #include <set>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/function_group_base.h"
 #include "ppapi/shared_impl/id_assignment.h"
 #include "ppapi/shared_impl/tracker_base.h"
 #include "webkit/plugins/ppapi/callbacks.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/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_cursor_control_impl.h"
 #include "webkit/plugins/ppapi/ppb_font_impl.h"
 #include "webkit/plugins/ppapi/ppb_text_input_impl.h"
 #include "webkit/plugins/ppapi/resource_creation_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using ppapi::CheckIdType;
 using ppapi::MakeTypedId;
 using ppapi::NPObjectVar;
 using ppapi::PPIdType;
 using ppapi::Var;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 ::ppapi::TrackerBase* GetTrackerBase() {
-  return HostGlobals::Get()->host_resource_tracker();
+  return ResourceTracker::Get();
 }
 
 }  // namespace
 
 typedef std::map<NPObject*, NPObjectVar*> NPObjectToNPObjectVarMap;
 
 struct ResourceTracker::InstanceData {
   InstanceData() : instance(0) {}
 
   // Non-owning pointer to the instance object. When a PluginInstance is
   // destroyed, it will notify us and we'll delete all associated data.
   PluginInstance* instance;
 
   // Tracks all live NPObjectVars used by this module so we can map NPObjects
   // to the corresponding object, and also release these properly if the
   // instance goes away when there are still refs. These are non-owning
   // references.
   NPObjectToNPObjectVarMap np_object_to_object_var;
 
   // Lazily allocated function proxies for the different interfaces.
   scoped_ptr< ::ppapi::FunctionGroupBase >
       function_proxies[::ppapi::proxy::INTERFACE_ID_COUNT];
 };
 
+// static
+ResourceTracker* ResourceTracker::global_tracker_ = NULL;
+ResourceTracker* ResourceTracker::singleton_override_ = NULL;
+
 ResourceTracker::ResourceTracker() {
   // Wire up the new shared resource tracker base to use our implementation.
   ::ppapi::TrackerBase::Init(&GetTrackerBase);
 }
 
 ResourceTracker::~ResourceTracker() {
 }
 
+// static
+ResourceTracker* ResourceTracker::Get() {
+  if (singleton_override_)
+    return singleton_override_;
+  if (!global_tracker_)
+    global_tracker_ = new ResourceTracker;
+  return global_tracker_;
+}
+
 void ResourceTracker::CleanupInstanceData(PP_Instance instance,
                                           bool delete_instance) {
   DLOG_IF(ERROR, !CheckIdType(instance, ::ppapi::PP_ID_TYPE_INSTANCE))
       << instance << " is not a PP_Instance.";
   InstanceMap::iterator found = instance_map_.find(instance);
   if (found == instance_map_.end()) {
     NOTREACHED();
     return;
   }
   InstanceData& data = *found->second;
@@ skipping 52 matching lines @@
     case ::ppapi::proxy::INTERFACE_ID_RESOURCE_CREATION:
       proxy.reset(new ResourceCreationImpl(instance));
       break;
     default:
       NOTREACHED();
   }
 
   return proxy.get();
 }
 
+::ppapi::VarTracker* ResourceTracker::GetVarTracker() {
+  return &var_tracker_;
+}
+
+::ppapi::ResourceTracker* ResourceTracker::GetResourceTracker() {
+  return this;
+}
+
 PP_Module ResourceTracker::GetModuleForInstance(PP_Instance instance) {
   PluginInstance* inst = GetInstance(instance);
   if (!inst)
     return 0;
   return inst->module()->pp_module();
 }
 
 void ResourceTracker::LastPluginRefWasDeleted(::ppapi::Resource* object) {
   ::ppapi::ResourceTracker::LastPluginRefWasDeleted(object);
 
@@ skipping 127 matching lines @@
 
 PluginModule* ResourceTracker::GetModule(PP_Module module) {
   DLOG_IF(ERROR, !CheckIdType(module, ::ppapi::PP_ID_TYPE_MODULE))
       << module << " is not a PP_Module.";
   ModuleMap::iterator found = module_map_.find(module);
   if (found == module_map_.end())
     return NULL;
   return found->second;
 }
 
+// static
+void ResourceTracker::SetSingletonOverride(ResourceTracker* tracker) {
+  DCHECK(!singleton_override_);
+  singleton_override_ = tracker;
+}
+
+// static
+void ResourceTracker::ClearSingletonOverride() {
+  DCHECK(singleton_override_);
+  singleton_override_ = NULL;
+}
+
 }  // namespace ppapi
 }  // namespace webkit