Rev the Flash interface to add new functionality.

ppapi/proxy/ppb_flash_proxy.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/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"
@@ skipping 25 matching lines @@
   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,
-                   PP_Point position,
-                   PP_Rect clip,
+                   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[]) {
   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(
       image_data->pp_instance());
   if (!dispatcher)
     return PP_FALSE;
 
   PPBFlash_DrawGlyphs_Params params;
   params.image_data = image_data->host_resource();
   params.font_desc.SetFromPPFontDescription(dispatcher, *font_desc, true);
   params.color = color;
-  params.position = position;
-  params.clip = clip;
+  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(),
                               &glyph_indices[0],
                               &glyph_indices[glyph_count]);
   params.glyph_advances.insert(params.glyph_advances.begin(),
                                &glyph_advances[0],
                                &glyph_advances[glyph_count]);
 
   PP_Bool result = PP_FALSE;
   dispatcher->Send(new PpapiHostMsg_PPBFlash_DrawGlyphs(
       API_ID_PPB_FLASH, params, &result));
   return result;
 }
 
+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.
+  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) {
   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);
 }
 
 int32_t Navigate(PP_Resource request_id,
                  const char* target,
-                 bool from_user_action) {
+                 PP_Bool from_user_action) {
   thunk::EnterResource<thunk::PPB_URLRequestInfo_API> enter(request_id, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
   PP_Instance instance = enter.resource()->pp_instance();
 
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_ERROR_FAILED;
 
   int32_t result = PP_ERROR_FAILED;
   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.
+  return Navigate(request_id, target, PP_FromBool(from_user_action));
+}
+
 void RunMessageLoop(PP_Instance instance) {
   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);
 }
 
@@ skipping 20 matching lines @@
   dispatcher->Send(new PpapiHostMsg_PPBFlash_GetLocalTimeZoneOffset(
       API_ID_PPB_FLASH, instance, t, &result));
   return result;
 }
 
 PP_Var GetCommandLineArgs(PP_Module /*pp_module*/) {
   std::string args = ProxyModule::GetInstance()->GetFlashCommandLineArgs();
   return StringVar::StringToPPVar(args);
 }
 
-const PPB_Flash flash_interface = {
+void PreLoadFontInWindows(const void* logfontw) {
+  // TODO(brettw) implement this.
+}
+
+const PPB_Flash_11 flash_interface_11 = {
+  &SetInstanceAlwaysOnTop,
+  &DrawGlyphs11,
+  &GetProxyForURL,
+  &Navigate11,
+  &RunMessageLoop,
+  &QuitMessageLoop,
+  &GetLocalTimeZoneOffset,
+  &GetCommandLineArgs
+};
+
+const PPB_Flash flash_interface_12 = {
   &SetInstanceAlwaysOnTop,
   &DrawGlyphs,
   &GetProxyForURL,
   &Navigate,
   &RunMessageLoop,
   &QuitMessageLoop,
   &GetLocalTimeZoneOffset,
-  &GetCommandLineArgs
+  &GetCommandLineArgs,
+  &PreLoadFontInWindows
 };
 
-InterfaceProxy* CreateFlashProxy(Dispatcher* dispatcher) {
-  return new PPB_Flash_Proxy(dispatcher);
-}
-
 }  // namespace
 
 PPB_Flash_Proxy::PPB_Flash_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       ppb_flash_impl_(NULL) {
   if (!dispatcher->IsPlugin())
     ppb_flash_impl_ = static_cast<const PPB_Flash*>(
         dispatcher->local_get_interface()(PPB_FLASH_INTERFACE));
 }
 
 PPB_Flash_Proxy::~PPB_Flash_Proxy() {
 }
 
 // static
-const PPB_Flash* PPB_Flash_Proxy::GetInterface() {
-  return &flash_interface;
+const PPB_Flash_11* PPB_Flash_Proxy::GetInterface11() {
+  return &flash_interface_11;
+}
+
+// static
+const PPB_Flash* PPB_Flash_Proxy::GetInterface12() {
+  return &flash_interface_12;
 }
 
 bool PPB_Flash_Proxy::OnMessageReceived(const IPC::Message& msg) {
   // Prevent the dispatcher from going away during a call to Navigate.
   // This must happen OUTSIDE of OnMsgNavigate since the handling code use
   // the dispatcher upon return of the function (sending the reply message).
   ScopedModuleReference death_grip(dispatcher());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Flash_Proxy, msg)
@@ skipping 29 matching lines @@
   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;
 
   *result = ppb_flash_impl_->DrawGlyphs(
       0,  // Unused instance param.
       params.image_data.host_resource(), &font_desc,
-      params.color, params.position, params.clip,
+      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]));
 }
 
 void PPB_Flash_Proxy::OnMsgGetProxyForURL(PP_Instance instance,
                                           const std::string& url,
                                           SerializedVarReturnValue result) {
   result.Return(dispatcher(), ppb_flash_impl_->GetProxyForURL(
       instance, url.c_str()));
 }
 
 void PPB_Flash_Proxy::OnMsgNavigate(PP_Instance instance,
                                     const PPB_URLRequestInfo_Data& data,
                                     const std::string& target,
-                                    bool from_user_action,
+                                    PP_Bool from_user_action,
                                     int32_t* result) {
   DCHECK(!dispatcher()->IsPlugin());
 
   // Validate the PP_Instance since we'll be constructing resources on its
   // behalf.
   HostDispatcher* host_dispatcher = static_cast<HostDispatcher*>(dispatcher());
   if (HostDispatcher::GetForInstance(instance) != host_dispatcher) {
     NOTREACHED();
     *result = PP_ERROR_BADARGUMENT;
     return;
@@ skipping 30 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