Introduce PPB_Flash_Font.

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 <limits>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 15 matching lines @@
 #include "ppapi/proxy/serialized_var.h"
 #include "ppapi/shared_impl/dir_contents.h"
 #include "ppapi/shared_impl/file_type_conversion.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/time_conversion.h"
 #include "ppapi/shared_impl/var.h"
+#include "ppapi/shared_impl/var_tracker.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_instance_api.h"
 #include "ppapi/thunk/ppb_url_request_info_api.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 using ppapi::thunk::EnterInstanceNoLock;
 using ppapi::thunk::EnterResourceNoLock;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 IPC::PlatformFileForTransit PlatformFileToPlatformFileForTransit(
     Dispatcher* dispatcher,
     int32_t* error,
     base::PlatformFile file) {
   if (*error != PP_OK)
     return IPC::InvalidPlatformFileForTransit();
   IPC::PlatformFileForTransit out_handle =
       dispatcher->ShareHandleWithRemote(file, true);
   if (out_handle == IPC::InvalidPlatformFileForTransit())
     *error = PP_ERROR_NOACCESS;
   return out_handle;
 }
 
 void InvokePrinting(PP_Instance instance) {
+  ProxyAutoLock lock;
+
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (dispatcher) {
     dispatcher->Send(new PpapiHostMsg_PPBFlash_InvokePrinting(
         API_ID_PPB_FLASH, instance));
   }
 }
 
 const PPB_Flash_Print_1_0 g_flash_print_interface = {
   &InvokePrinting
 };
@@ skipping 82 matching lines @@
       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;
 
   PPBFlash_DrawGlyphs_Params params;
   params.image_data = image_data->host_resource();
-  params.font_desc.SetFromPPFontDescription(dispatcher(), *font_desc, true);
+  params.font_desc.SetFromPPFontDescription(*font_desc);
   params.color = color;
   params.position = *position;
   params.clip = *clip;
   for (int i = 0; i < 3; i++) {
     for (int j = 0; j < 3; j++)
       params.transformation[i][j] = transformation[i][j];
   }
   params.allow_subpixel_aa = allow_subpixel_aa;
 
   params.glyph_indices.insert(params.glyph_indices.begin(),
@@ skipping 448 matching lines @@
 
 void PPB_Flash_Proxy::OnHostMsgDrawGlyphs(
     PP_Instance instance,
     const PPBFlash_DrawGlyphs_Params& params,
     PP_Bool* result) {
   *result = PP_FALSE;
   EnterInstanceNoLock enter(instance);
   if (enter.failed())
     return;
 
-  PP_FontDescription_Dev font_desc;
-  params.font_desc.SetToPPFontDescription(dispatcher(), &font_desc, false);
-
   if (params.glyph_indices.size() != params.glyph_advances.size() ||
       params.glyph_indices.empty())
     return;
 
+  PP_FontDescription_Dev font_desc;
+  params.font_desc.SetToPPFontDescription(&font_desc);
+
   *result = enter.functions()->GetFlashAPI()->DrawGlyphs(
       0,  // Unused instance param.
       params.image_data.host_resource(), &font_desc,
       params.color, &params.position, &params.clip,
       const_cast<float(*)[3]>(params.transformation),
       params.allow_subpixel_aa,
       static_cast<uint32_t>(params.glyph_indices.size()),
       const_cast<uint16_t*>(&params.glyph_indices[0]),
       const_cast<PP_Point*>(&params.glyph_advances[0]));
+
+  // SetToPPFontDescription() creates a var which is owned by the caller.
+  PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(font_desc.face);
 }
 
 void PPB_Flash_Proxy::OnHostMsgGetProxyForURL(PP_Instance instance,
                                               const std::string& url,
                                               SerializedVarReturnValue result) {
   EnterInstanceNoLock enter(instance);
   if (enter.succeeded()) {
     result.Return(dispatcher(),
                   enter.functions()->GetFlashAPI()->GetProxyForURL(
                       instance, url.c_str()));
@@ skipping 215 matching lines @@
   // It's rarely used enough that we just request this interface when needed.
   const PPB_Flash_Print_1_0* print_interface =
       static_cast<const PPB_Flash_Print_1_0*>(
           dispatcher()->local_get_interface()(PPB_FLASH_PRINT_INTERFACE_1_0));
   if (print_interface)
     print_interface->InvokePrinting(instance);
 }
 
 }  // namespace proxy
 }  // namespace ppapi