Delete FunctionGroupBase from Pepper.

webkit/plugins/ppapi/host_globals.cc

 // Copyright (c) 2012 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/host_globals.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/utf_string_conversions.h"
 #include "ppapi/shared_impl/api_id.h"
-#include "ppapi/shared_impl/function_group_base.h"
 #include "ppapi/shared_impl/id_assignment.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebConsoleMessage.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "webkit/plugins/plugin_switches.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
-#include "webkit/plugins/ppapi/resource_creation_impl.h"
 
 using ppapi::CheckIdType;
 using ppapi::MakeTypedId;
 using ppapi::PPIdType;
 using WebKit::WebConsoleMessage;
 using WebKit::WebString;
 
 namespace webkit {
 namespace ppapi {
 
@@ skipping 31 matching lines @@
   std::string result = source;
   if (!result.empty())
     result.append(": ");
   result.append(message);
   return WebConsoleMessage(LogLevelToWebLogLevel(level),
                            WebString(UTF8ToUTF16(result)));
 }
 
 }  // namespace
 
-struct HostGlobals::InstanceData {

[brettw, 2012/04/21 19:50:01]

I deleted this since I deleted the function_proxies array so I could just store
the PluginInstance var directly in the map.

-  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;
-
-  // Lazily allocated function proxies for the different interfaces.
-  scoped_ptr< ::ppapi::FunctionGroupBase >
-      function_proxies[::ppapi::API_ID_COUNT];
-};
-
 HostGlobals* HostGlobals::host_globals_ = NULL;
 
 HostGlobals::HostGlobals() : ::ppapi::PpapiGlobals() {
   DCHECK(!host_globals_);
   host_globals_ = this;
 }
 
 HostGlobals::HostGlobals(::ppapi::PpapiGlobals::ForTest for_test)
     : ::ppapi::PpapiGlobals(for_test) {
   DCHECK(!host_globals_);
 }
 
 HostGlobals::~HostGlobals() {
   DCHECK(host_globals_ == this || !host_globals_);
   host_globals_ = NULL;
 }
 
 ::ppapi::ResourceTracker* HostGlobals::GetResourceTracker() {
   return &resource_tracker_;
 }
 
 ::ppapi::VarTracker* HostGlobals::GetVarTracker() {
   return &host_var_tracker_;
 }
 
 ::ppapi::CallbackTracker* HostGlobals::GetCallbackTrackerForInstance(
     PP_Instance instance) {
-  std::map<PP_Instance, linked_ptr<InstanceData> >::iterator found =
-      instance_map_.find(instance);
+  InstanceMap::iterator found = instance_map_.find(instance);
   if (found == instance_map_.end())
     return NULL;
-
-  return found->second->instance->module()->GetCallbackTracker();
+  return found->second->module()->GetCallbackTracker();
 }
 
-::ppapi::FunctionGroupBase* HostGlobals::GetFunctionAPI(PP_Instance pp_instance,
-                                                        ::ppapi::ApiID id) {
-  // Get the instance object. This also ensures that the instance data is in
-  // the map, since we need it below.
+::ppapi::thunk::PPB_Instance_API* HostGlobals::GetInstanceAPI(
+    PP_Instance instance) {
+  // The InstanceAPI is just implemented by the PluginInstance object.
+  return GetInstance(instance);
+}
+
+::ppapi::thunk::ResourceCreationAPI* HostGlobals::GetResourceCreationAPI(
+    PP_Instance pp_instance) {
   PluginInstance* instance = GetInstance(pp_instance);
   if (!instance)
     return NULL;
-
-  // The instance one is special, since it's just implemented by the instance
-  // object.
-  if (id == ::ppapi::API_ID_PPB_INSTANCE)
-    return instance;
-
-  scoped_ptr< ::ppapi::FunctionGroupBase >& proxy =
-      instance_map_[pp_instance]->function_proxies[id];
-  if (proxy.get())
-    return proxy.get();
-
-  switch (id) {
-    case ::ppapi::API_ID_RESOURCE_CREATION:
-      proxy.reset(new ResourceCreationImpl(instance));
-      break;
-    default:
-      NOTREACHED();
-  }
-
-  return proxy.get();
+  return &instance->resource_creation();
 }
 
 PP_Module HostGlobals::GetModuleForInstance(PP_Instance instance) {
   PluginInstance* inst = GetInstance(instance);
   if (!inst)
     return 0;
   return inst->module()->pp_module();
 }
 
 std::string HostGlobals::GetCommandLine() {
@@ skipping 95 matching lines @@
   //
   // Need to make sure the random number isn't a duplicate or 0.
   PP_Instance new_instance;
   do {
     new_instance = MakeTypedId(static_cast<PP_Instance>(base::RandUint64()),
                                ::ppapi::PP_ID_TYPE_INSTANCE);
   } while (!new_instance ||
            instance_map_.find(new_instance) != instance_map_.end() ||
            !instance->module()->ReserveInstanceID(new_instance));
 
-  instance_map_[new_instance] = linked_ptr<InstanceData>(new InstanceData);
-  instance_map_[new_instance]->instance = instance;
+  instance_map_[new_instance] = instance;
 
   resource_tracker_.DidCreateInstance(new_instance);
   return new_instance;
 }
 
 void HostGlobals::InstanceDeleted(PP_Instance instance) {
   resource_tracker_.DidDeleteInstance(instance);
   host_var_tracker_.ForceFreeNPObjectsForInstance(instance);
   instance_map_.erase(instance);
 }
 
 void HostGlobals::InstanceCrashed(PP_Instance instance) {
   resource_tracker_.DidDeleteInstance(instance);
   host_var_tracker_.ForceFreeNPObjectsForInstance(instance);
 }
 
 PluginInstance* HostGlobals::GetInstance(PP_Instance 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())
     return NULL;
-  return found->second->instance;
+  return found->second;
 }
 
 bool HostGlobals::IsHostGlobals() const {
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit