New thunk system for Pepper proxy and implementation

ppapi/proxy/plugin_dispatcher.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_dispatcher.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_channel.h"
 #include "gpu/common/gpu_trace_event.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_message_filter.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/plugin_var_serialization_rules.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppp_class_proxy.h"
+#include "ppapi/proxy/resource_creation_proxy.h"
+#include "ppapi/shared_impl/tracker_base.h"
 
 #if defined(OS_POSIX)
 #include "base/eintr_wrapper.h"
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 namespace pp {
 namespace proxy {
 
 namespace {
 
 typedef std::map<PP_Instance, PluginDispatcher*> InstanceToDispatcherMap;
 InstanceToDispatcherMap* g_instance_to_dispatcher = NULL;
 
 }  // namespace
 
 PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
                                    GetInterfaceFunc get_interface)
     : Dispatcher(remote_process_handle, get_interface) {
   SetSerializationRules(new PluginVarSerializationRules);
 
   // As a plugin, we always support the PPP_Class interface. There's no
   // GetInterface call or name for it, so we insert it into our table now.
   target_proxies_[INTERFACE_ID_PPP_CLASS].reset(new PPP_Class_Proxy(this));
+
+  ::ppapi::shared_impl::TrackerBase::Init(
+      &PluginResourceTracker::GetTrackerBaseInstance);
 }
 
 PluginDispatcher::~PluginDispatcher() {
 }
 
 // static
 PluginDispatcher* PluginDispatcher::GetForInstance(PP_Instance instance) {
   if (!g_instance_to_dispatcher)
     return NULL;
   InstanceToDispatcherMap::iterator found = g_instance_to_dispatcher->find(
@@ skipping 134 matching lines @@
       NOTREACHED();
     }
   }
 }
 
 InstanceData* PluginDispatcher::GetInstanceData(PP_Instance instance) {
   InstanceDataMap::iterator it = instance_map_.find(instance);
   return (it == instance_map_.end()) ? NULL : &it->second;
 }
 
+::ppapi::shared_impl::FunctionGroupBase* PluginDispatcher::GetFunctionAPI(
+    pp::proxy::InterfaceID id) {
+  if (function_proxies_[id].get())
+    return function_proxies_[id].get();
+
+  if (id == INTERFACE_ID_RESOURCE_CREATION)
+    function_proxies_[id].reset(new ResourceCreationProxy(this));
+
+  return function_proxies_[id].get();
+}
+
 void PluginDispatcher::ForceFreeAllInstances() {
   if (!g_instance_to_dispatcher)
     return;
 
   // Iterating will remove each item from the map, so we need to make a copy
   // to avoid things changing out from under is.
   InstanceToDispatcherMap temp_map = *g_instance_to_dispatcher;
   for (InstanceToDispatcherMap::iterator i = temp_map.begin();
        i != temp_map.end(); ++i) {
     if (i->second == this) {
@@ skipping 26 matching lines @@
   if (!interface_functions)
     return;
   target_proxies_[info->id].reset(
       info->create_proxy(this, interface_functions));
   *result = true;
 }
 
 }  // namespace proxy
 }  // namespace pp