New thunk system for Pepper proxy and implementation

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/tracker_base.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/resource.h"
+#include "webkit/plugins/ppapi/resource_creation_impl.h"
 #include "webkit/plugins/ppapi/var.h"
 
 enum PPIdType {
   PP_ID_TYPE_MODULE,
   PP_ID_TYPE_INSTANCE,
   PP_ID_TYPE_RESOURCE,
   PP_ID_TYPE_VAR,
   PP_ID_TYPE_COUNT
 };
 
 static const unsigned int kPPIdTypeBits = 2;
 COMPILE_ASSERT(PP_ID_TYPE_COUNT <= (1<<kPPIdTypeBits),
                kPPIdTypeBits_is_too_small_for_all_id_types);
 
 template <typename T> static inline T MakeTypedId(T value, PPIdType type) {
   return (value << kPPIdTypeBits) | static_cast<T>(type);
 }
 
 template <typename T> static inline bool CheckIdType(T id, PPIdType type) {
   // 0 is a valid resource.
   if (!id)
     return true;
   const T mask = (static_cast<T>(1) << kPPIdTypeBits) - 1;
   return (id & mask) == type;
 }
 
+namespace shared_impl = ::ppapi::shared_impl;
+
 namespace webkit {
 namespace ppapi {
 
+namespace {
+
+shared_impl::TrackerBase* GetTrackerBase() {
+  return ResourceTracker::Get();
+}
+
+}  // namespace
+
 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;
 
   // Resources and object vars associated with the instance.
   ResourceSet resources;
   VarSet object_vars;
 };
 
 scoped_refptr<Resource> ResourceTracker::GetResource(PP_Resource res) const {
   DLOG_IF(ERROR, !CheckIdType(res, PP_ID_TYPE_RESOURCE))
       << res << " is not a PP_Resource.";
   ResourceMap::const_iterator result = live_resources_.find(res);
   if (result == live_resources_.end()) {
     return scoped_refptr<Resource>();
   }
   return result->second.first;
 }
 
 // static
 ResourceTracker* ResourceTracker::global_tracker_ = NULL;
 ResourceTracker* ResourceTracker::singleton_override_ = NULL;
 
 ResourceTracker::ResourceTracker()
     : last_resource_id_(0),
       last_var_id_(0) {
+  // Wire up the new shared resource tracker base to use our implementation.
+  shared_impl::TrackerBase::Init(&GetTrackerBase);
 }
 
 ResourceTracker::~ResourceTracker() {
 }
 
 // static
 ResourceTracker* ResourceTracker::Get() {
   if (singleton_override_)
     return singleton_override_;
   if (!global_tracker_)
@@ skipping 134 matching lines @@
 
 uint32 ResourceTracker::GetLiveObjectsForInstance(
     PP_Instance instance) const {
   InstanceMap::const_iterator found = instance_map_.find(instance);
   if (found == instance_map_.end())
     return 0;
   return static_cast<uint32>(found->second.resources.size() +
                              found->second.object_vars.size());
 }
 
+shared_impl::ResourceObjectBase* ResourceTracker::GetResourceAPI(
+    PP_Resource res) {
+  DLOG_IF(ERROR, !CheckIdType(res, PP_ID_TYPE_RESOURCE))
+      << res << " is not a PP_Resource.";
+  ResourceMap::const_iterator result = live_resources_.find(res);
+  if (result == live_resources_.end())
+    return NULL;
+  return result->second.first.get();
+}
+
+shared_impl::FunctionGroupBase* ResourceTracker::GetFunctionAPI(
+    PP_Instance inst,
+    pp::proxy::InterfaceID id) {
+  if (function_proxies_[id].get())
+    return function_proxies_[id].get();
+
+  if (id == ::pp::proxy::INTERFACE_ID_RESOURCE_CREATION)
+    function_proxies_[id].reset(new ResourceCreationImpl());
+
+  return function_proxies_[id].get();
+}
+
 scoped_refptr<Var> ResourceTracker::GetVar(int32 var_id) const {
   DLOG_IF(ERROR, !CheckIdType(var_id, PP_ID_TYPE_VAR))
       << var_id << " is not a PP_Var ID.";
   VarMap::const_iterator result = live_vars_.find(var_id);
   if (result == live_vars_.end())
     return scoped_refptr<Var>();
   return result->second.first;
 }
 
 bool ResourceTracker::AddRefVar(int32 var_id) {
@@ skipping 111 matching lines @@
 
 // static
 void ResourceTracker::ClearSingletonOverride() {
   DCHECK(singleton_override_);
   singleton_override_ = NULL;
 }
 
 }  // namespace ppapi
 }  // namespace webkit