reland 121901, PPAPI: Add unlocking for PPP calls and callbacks...

ppapi/proxy/ppb_flash_proxy.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 "ppapi/proxy/ppb_flash_proxy.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/proxy_module.h"
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_url_request_info_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 void SetInstanceAlwaysOnTop(PP_Instance pp_instance, PP_Bool on_top) {
+  ProxyAutoLock lock;
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(pp_instance);
   if (dispatcher) {
     dispatcher->Send(new PpapiHostMsg_PPBFlash_SetInstanceAlwaysOnTop(
         API_ID_PPB_FLASH, pp_instance, on_top));
   }
 }
 
 PP_Bool DrawGlyphs(PP_Instance instance,
                    PP_Resource pp_image_data,
                    const PP_FontDescription_Dev* font_desc,
                    uint32_t color,
                    const PP_Point* position,
                    const PP_Rect* clip,
                    const float transformation[3][3],
                    PP_Bool allow_subpixel_aa,
                    uint32_t glyph_count,
                    const uint16_t glyph_indices[],
                    const PP_Point glyph_advances[]) {
+  ProxyAutoLock lock;
   Resource* image_data =
       PpapiGlobals::Get()->GetResourceTracker()->GetResource(pp_image_data);
   if (!image_data)
     return PP_FALSE;
   // The instance parameter isn't strictly necessary but we check that it
   // matches anyway.
   if (image_data->pp_instance() != instance)
     return PP_FALSE;
 
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(
@@ skipping 29 matching lines @@
 PP_Bool DrawGlyphs11(PP_Instance instance,
                      PP_Resource pp_image_data,
                      const PP_FontDescription_Dev* font_desc,
                      uint32_t color,
                      PP_Point position,
                      PP_Rect clip,
                      const float transformation[3][3],
                      uint32_t glyph_count,
                      const uint16_t glyph_indices[],
                      const PP_Point glyph_advances[]) {
-  // Backwards-compatible version.
+  // Backwards-compatible version. DrawGlyphs locks; no need to lock here.
   return DrawGlyphs(instance, pp_image_data, font_desc, color, &position,
                     &clip, transformation, PP_TRUE, glyph_count, glyph_indices,
                     glyph_advances);
 }
 
 PP_Var GetProxyForURL(PP_Instance instance, const char* url) {
+  ProxyAutoLock lock;
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   ReceiveSerializedVarReturnValue result;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_GetProxyForURL(
       API_ID_PPB_FLASH, instance, url, &result));
   return result.Return(dispatcher);
 }
 
@@ skipping 13 matching lines @@
   dispatcher->Send(new PpapiHostMsg_PPBFlash_Navigate(
       API_ID_PPB_FLASH,
       instance, enter.object()->GetData(), target, from_user_action,
       &result));
   return result;
 }
 
 int32_t Navigate11(PP_Resource request_id,
                    const char* target,
                    bool from_user_action) {
-  // Backwards-compatible version.
+  // Backwards-compatible version. Navigate locks; no need to lock here.
   return Navigate(request_id, target, PP_FromBool(from_user_action));
 }
 
 void RunMessageLoop(PP_Instance instance) {
+  ProxyAutoLock lock;
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   IPC::SyncMessage* msg = new PpapiHostMsg_PPBFlash_RunMessageLoop(
       API_ID_PPB_FLASH, instance);
   msg->EnableMessagePumping();
   dispatcher->Send(msg);
 }
 
 void QuitMessageLoop(PP_Instance instance) {
+  ProxyAutoLock lock;
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_QuitMessageLoop(
       API_ID_PPB_FLASH, instance));
 }
 
 double GetLocalTimeZoneOffset(PP_Instance instance, PP_Time t) {
+  ProxyAutoLock lock;
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0.0;
 
   // TODO(brettw) on Windows it should be possible to do the time calculation
   // in-process since it doesn't need to read files on disk. This will improve
   // performance.
   //
   // On Linux, it would be better to go directly to the browser process for
   // this message rather than proxy it through some instance in a renderer.
   double result = 0;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_GetLocalTimeZoneOffset(
       API_ID_PPB_FLASH, instance, t, &result));
   return result;
 }
 
 PP_Var GetCommandLineArgs(PP_Module /*pp_module*/) {
+  ProxyAutoLock lock;
   std::string args = ProxyModule::GetInstance()->GetFlashCommandLineArgs();
   return StringVar::StringToPPVar(args);
 }
 
 void PreLoadFontWin(const void* logfontw) {
+  ProxyAutoLock lock;
   PluginGlobals::Get()->plugin_proxy_delegate()->PreCacheFont(logfontw);
 }
 
 const PPB_Flash_11 flash_interface_11 = {
   &SetInstanceAlwaysOnTop,
   &DrawGlyphs11,
   &GetProxyForURL,
   &Navigate11,
   &RunMessageLoop,
   &QuitMessageLoop,
@@ skipping 145 matching lines @@
 }
 
 void PPB_Flash_Proxy::OnMsgGetLocalTimeZoneOffset(PP_Instance instance,
                                                   PP_Time t,
                                                   double* result) {
   *result = ppb_flash_impl_->GetLocalTimeZoneOffset(instance, t);
 }
 
 }  // namespace proxy
 }  // namespace ppapi