Rev the Flash interface to add new functionality.

webkit/plugins/ppapi/ppb_flash_impl.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 "webkit/plugins/ppapi/ppb_flash_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/message_loop.h"
@@ skipping 37 matching lines @@
   if (!instance)
     return;
   instance->set_always_on_top(PPBoolToBool(on_top));
 }
 
 
 PP_Bool DrawGlyphs(PP_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[]) {
   EnterResource<PPB_ImageData_API> enter(pp_image_data, true);
   if (enter.failed())
     return PP_FALSE;
   PPB_ImageData_Impl* image_resource =
       static_cast<PPB_ImageData_Impl*>(enter.object());
 
   ImageDataAutoMapper mapper(image_resource);
@@ skipping 13 matching lines @@
       SkTypeface::CreateFromName(face_name->value().c_str(),
                                  static_cast<SkTypeface::Style>(style));
   if (!typeface)
     return PP_FALSE;
 
   // Set up the canvas.
   SkCanvas* canvas = image_resource->mapped_canvas();
   canvas->save();
 
   // Clip is applied in pixels before the transform.
-  SkRect clip_rect = { clip.point.x, clip.point.y,
-                       clip.point.x + clip.size.width,
-                       clip.point.y + clip.size.height };
+  SkRect clip_rect = { clip->point.x, clip->point.y,
+                       clip->point.x + clip->size.width,
+                       clip->point.y + clip->size.height };
   canvas->clipRect(clip_rect);
 
   // -- Do not return early below this. The canvas needs restoring and the
   // typeface will leak if it's not assigned to the paint (it's refcounted and
   // the refcount is currently 0).
 
   // Convert & set the matrix.
   SkMatrix matrix;
   matrix.set(SkMatrix::kMScaleX, SkFloatToScalar(transformation[0][0]));
   matrix.set(SkMatrix::kMSkewX,  SkFloatToScalar(transformation[0][1]));
   matrix.set(SkMatrix::kMTransX, SkFloatToScalar(transformation[0][2]));
   matrix.set(SkMatrix::kMSkewY,  SkFloatToScalar(transformation[1][0]));
   matrix.set(SkMatrix::kMScaleY, SkFloatToScalar(transformation[1][1]));
   matrix.set(SkMatrix::kMTransY, SkFloatToScalar(transformation[1][2]));
   matrix.set(SkMatrix::kMPersp0, SkFloatToScalar(transformation[2][0]));
   matrix.set(SkMatrix::kMPersp1, SkFloatToScalar(transformation[2][1]));
   matrix.set(SkMatrix::kMPersp2, SkFloatToScalar(transformation[2][2]));
   canvas->concat(matrix);
 
   SkPaint paint;
   paint.setColor(color);
   paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint.setAntiAlias(true);
   paint.setHinting(SkPaint::kFull_Hinting);
   paint.setTextSize(SkIntToScalar(font_desc->size));
   paint.setTypeface(typeface);  // Takes a ref and manages lifetime.
-  paint.setSubpixelText(true);
-  paint.setLCDRenderText(true);
+  if (allow_subpixel_aa) {
+    paint.setSubpixelText(true);
+    paint.setLCDRenderText(true);
+  }
 
-  SkScalar x = SkIntToScalar(position.x);
-  SkScalar y = SkIntToScalar(position.y);
+  SkScalar x = SkIntToScalar(position->x);
+  SkScalar y = SkIntToScalar(position->y);
 
   // Build up the skia advances.
   if (glyph_count == 0)
     return PP_TRUE;
   std::vector<SkPoint> storage;
   storage.resize(glyph_count);
   SkPoint* sk_positions = &storage[0];
   for (uint32_t i = 0; i < glyph_count; i++) {
     sk_positions[i].set(x, y);
     x += SkFloatToScalar(glyph_advances[i].x);
     y += SkFloatToScalar(glyph_advances[i].y);
   }
 
   canvas->drawPosText(glyph_indices, glyph_count * 2, sk_positions, paint);
 
   canvas->restore();
   return PP_TRUE;
 }
 
+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[]) {
+  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 pp_instance, const char* url) {
   PluginInstance* instance = HostGlobals::Get()->GetInstance(pp_instance);
   if (!instance)
     return PP_MakeUndefined();
 
   GURL gurl(url);
   if (!gurl.is_valid())
     return PP_MakeUndefined();
 
   std::string proxy_host = instance->delegate()->ResolveProxy(gurl);
   if (proxy_host.empty())
     return PP_MakeUndefined();  // No proxy.
   return StringVar::StringToPPVar(proxy_host);
 }
 
 int32_t Navigate(PP_Resource request_id,
                  const char* target,
-                 bool from_user_action) {
+                 PP_Bool from_user_action) {
   EnterResource<PPB_URLRequestInfo_API> enter(request_id, true);
   if (enter.failed())
     return PP_ERROR_BADRESOURCE;
   PPB_URLRequestInfo_Impl* request =
       static_cast<PPB_URLRequestInfo_Impl*>(enter.object());
 
   if (!target)
     return PP_ERROR_BADARGUMENT;
 
   PluginInstance* plugin_instance = ResourceHelper::GetPluginInstance(request);
   if (!plugin_instance)
     return PP_ERROR_FAILED;
-  return plugin_instance->Navigate(request, target, from_user_action);
+  return plugin_instance->Navigate(request, target,
+                                   PP_ToBool(from_user_action));
+}
+
+int32_t Navigate11(PP_Resource request_id,
+                   const char* target,
+                   bool from_user_action) {
+  return Navigate(request_id, target, PP_FromBool(from_user_action));
 }
 
 void RunMessageLoop(PP_Instance instance) {
   bool old_state = MessageLoop::current()->NestableTasksAllowed();
   MessageLoop::current()->SetNestableTasksAllowed(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->SetNestableTasksAllowed(old_state);
 }
 
 void QuitMessageLoop(PP_Instance instance) {
@@ skipping 24 matching lines @@
     return PP_MakeUndefined();
 
   PluginInstance* instance = module->GetSomeInstance();
   if (!instance)
     return PP_MakeUndefined();
 
   std::string args = instance->delegate()->GetFlashCommandLineArgs();
   return StringVar::StringToPPVar(args);
 }
 
-const PPB_Flash ppb_flash = {
+void PreLoadFontInWindows(const void* logfontw) {
+  // TODO(brettw) implement this.
+}
+
+const PPB_Flash_11 ppb_flash_11 = {
+  &SetInstanceAlwaysOnTop,
+  &DrawGlyphs11,
+  &GetProxyForURL,
+  &Navigate11,
+  &RunMessageLoop,
+  &QuitMessageLoop,
+  &GetLocalTimeZoneOffset,
+  &GetCommandLineArgs
+};
+
+const PPB_Flash ppb_flash_12 = {
   &SetInstanceAlwaysOnTop,
   &DrawGlyphs,
   &GetProxyForURL,
   &Navigate,
   &RunMessageLoop,
   &QuitMessageLoop,
   &GetLocalTimeZoneOffset,
-  &GetCommandLineArgs
+  &GetCommandLineArgs,
+  &PreLoadFontInWindows
 };
 
 }  // namespace
 
 // static
-const PPB_Flash* PPB_Flash_Impl::GetInterface() {
-  return &ppb_flash;
+const PPB_Flash_11* PPB_Flash_Impl::GetInterface11() {
+  return &ppb_flash_11;
+}
+
+// static
+const PPB_Flash* PPB_Flash_Impl::GetInterface12() {
+  return &ppb_flash_12;
 }
 
 }  // namespace ppapi
 }  // namespace webkit