Chromium side of supporting property enumeration, memory allocation, querying...

webkit/glue/plugins/pepper_plugin_module.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_plugin_module.h"
 
 #include <set>
 
+#include "base/message_loop_proxy.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
+#include "base/time.h"
 #include "third_party/ppapi/c/ppb_core.h"
 #include "third_party/ppapi/c/ppb_device_context_2d.h"
 #include "third_party/ppapi/c/ppb_image_data.h"
 #include "third_party/ppapi/c/ppb_instance.h"
 #include "third_party/ppapi/c/ppb_var.h"
 #include "third_party/ppapi/c/ppp.h"
 #include "third_party/ppapi/c/ppp_instance.h"
 #include "third_party/ppapi/c/pp_module.h"
 #include "third_party/ppapi/c/pp_resource.h"
 #include "third_party/ppapi/c/pp_var.h"
@@ skipping 12 matching lines @@
 
 // Maintains all currently loaded plugin libs for validating PP_Module
 // identifiers.
 typedef std::set<PluginModule*> PluginModuleSet;
 
 PluginModuleSet* GetLivePluginSet() {
   static PluginModuleSet live_plugin_libs;
   return &live_plugin_libs;
 }
 
+base::MessageLoopProxy* GetMainThreadMessageLoop() {
+  static scoped_refptr<base::MessageLoopProxy> proxy(
+      base::MessageLoopProxy::CreateForCurrentThread());
+  return proxy.get();
+}
+
 // PPB_Core --------------------------------------------------------------------
 
 void AddRefResource(PP_Resource resource) {
   Resource* res = ResourceTracker::Get()->GetResource(resource);
   if (!res) {
     DLOG(WARNING) << "AddRef()ing a nonexistent resource";
     return;
   }
   res->AddRef();
 }
 
 void ReleaseResource(PP_Resource resource) {
   Resource* res = ResourceTracker::Get()->GetResource(resource);
   if (!res) {
     DLOG(WARNING) << "Release()ing a nonexistent resource";
     return;
   }
   res->Release();
 }
 
+void* MemAlloc(size_t num_bytes) {
+  return malloc(num_bytes);
+}
+
+void MemFree(void* ptr) {
+  free(ptr);
+}
+
+double GetTime() {
+  return base::Time::Now().ToDoubleT();
+}
+
+void CallOnMainThread(int delay_in_msec, void (*func)(void*), void* context) {
+  GetMainThreadMessageLoop()->PostDelayedTask(
+      FROM_HERE,
+      NewRunnableFunction(func, context),
+      delay_in_msec);
+}
+
 const PPB_Core core_interface = {
   &AddRefResource,
   &ReleaseResource,
+  &MemAlloc,
+  &MemFree,
+  &GetTime,
+  &CallOnMainThread
 };
 
 // GetInterface ----------------------------------------------------------------
 
 const void* GetInterface(const char* name) {
   if (strcmp(name, PPB_CORE_INTERFACE) == 0)
     return &core_interface;
   if (strcmp(name, PPB_VAR_INTERFACE) == 0)
     return GetVarInterface();
   if (strcmp(name, PPB_INSTANCE_INTERFACE) == 0)
     return PluginInstance::GetInterface();
   if (strcmp(name, PPB_IMAGEDATA_INTERFACE) == 0)
     return ImageData::GetInterface();
   if (strcmp(name, PPB_DEVICECONTEXT2D_INTERFACE) == 0)
     return DeviceContext2D::GetInterface();
   return NULL;
 }
 
 }  // namespace
 
 PluginModule::PluginModule(const FilePath& filename)
     : filename_(filename),
       initialized_(false),
       library_(0),
       ppp_get_interface_(NULL) {
+  GetMainThreadMessageLoop();  // Initialize the main thread message loop.
   GetLivePluginSet()->insert(this);
 }
 
 PluginModule::~PluginModule() {
   // When the module is being deleted, there should be no more instances still
   // holding a reference to us.
   DCHECK(instances_.empty());
 
   GetLivePluginSet()->erase(this);
 
@@ skipping 94 matching lines @@
 
 void PluginModule::InstanceCreated(PluginInstance* instance) {
   instances_.insert(instance);
 }
 
 void PluginModule::InstanceDeleted(PluginInstance* instance) {
   instances_.erase(instance);
 }
 
 }  // namespace pepper