Add a Flash API to get the device ID.

ppapi/cpp/private/flash.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/cpp/private/flash.h"
 
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/dev/font_dev.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance_handle.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/c/private/ppb_flash.h"
 
 namespace pp {
 
 namespace {
 
 template <> const char* interface_name<PPB_Flash>() {

[raymes, 2012/04/11 00:16:11]

In other reviews I've been told to explicitly have
PPB_Flash_12_2/PPB_FLASH_INTERFACE here. Not sure which is the most accepted
style.

   return PPB_FLASH_INTERFACE;
 }
 
+template <> const char* interface_name<PPB_Flash_12_1>() {
+  return PPB_FLASH_INTERFACE_12_1;
+}
+
 template <> const char* interface_name<PPB_Flash_12_0>() {
   return PPB_FLASH_INTERFACE_12_0;
 }
 
 template <> const char* interface_name<PPB_Flash_11>() {
   return PPB_FLASH_INTERFACE_11_0;
 }
 
 }  // namespace
 
 namespace flash {
 
 // static
 bool Flash::IsAvailable() {
-  return has_interface<PPB_Flash>() ||
+  return has_interface<PPB_Flash_12_2>() ||
+         has_interface<PPB_Flash_12_1>() ||
          has_interface<PPB_Flash_12_0>() ||
          has_interface<PPB_Flash_11>();
 }
 
 // static
 void Flash::SetInstanceAlwaysOnTop(const InstanceHandle& instance,
                                    bool on_top) {
-  if (has_interface<PPB_Flash>()) {
-    get_interface<PPB_Flash>()->SetInstanceAlwaysOnTop(instance.pp_instance(),
-                                                       PP_FromBool(on_top));
+  if (has_interface<PPB_Flash_12_2>()) {
+    get_interface<PPB_Flash_12_2>()->SetInstanceAlwaysOnTop(
+        instance.pp_instance(), PP_FromBool(on_top));
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    get_interface<PPB_Flash_12_1>()->SetInstanceAlwaysOnTop(
+        instance.pp_instance(), PP_FromBool(on_top));
   } else if (has_interface<PPB_Flash_12_0>()) {
     get_interface<PPB_Flash_12_0>()->SetInstanceAlwaysOnTop(
         instance.pp_instance(), PP_FromBool(on_top));
   } else if (has_interface<PPB_Flash_11>()) {
     get_interface<PPB_Flash_11>()->SetInstanceAlwaysOnTop(
         instance.pp_instance(), PP_FromBool(on_top));
   }
 }
 
 // static
 bool Flash::DrawGlyphs(const InstanceHandle& instance,
                        ImageData* image,
                        const FontDescription_Dev& font_desc,
                        uint32_t color,
                        const Point& position,
                        const Rect& clip,
                        const float transformation[3][3],
                        bool allow_subpixel_aa,
                        uint32_t glyph_count,
                        const uint16_t glyph_indices[],
                        const PP_Point glyph_advances[]) {
   bool rv = false;
-  if (has_interface<PPB_Flash>()) {
-    rv = PP_ToBool(get_interface<PPB_Flash>()->DrawGlyphs(
+  if (has_interface<PPB_Flash_12_2>()) {
+    rv = PP_ToBool(get_interface<PPB_Flash_12_2>()->DrawGlyphs(
         instance.pp_instance(),
         image->pp_resource(),
         &font_desc.pp_font_description(),
+        color,
+        &position.pp_point(),
+        &clip.pp_rect(),
+        transformation,
+        PP_FromBool(allow_subpixel_aa),
+        glyph_count,
+        glyph_indices,
+        glyph_advances));
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = PP_ToBool(get_interface<PPB_Flash_12_1>()->DrawGlyphs(
+        instance.pp_instance(),
+        image->pp_resource(),
+        &font_desc.pp_font_description(),
         color,
         &position.pp_point(),
         &clip.pp_rect(),
         transformation,
         PP_FromBool(allow_subpixel_aa),
         glyph_count,
         glyph_indices,
         glyph_advances));
   } else if (has_interface<PPB_Flash_12_0>()) {
     rv = PP_ToBool(get_interface<PPB_Flash_12_0>()->DrawGlyphs(
@@ skipping 21 matching lines @@
         glyph_indices,
         glyph_advances));
   }
   return rv;
 }
 
 // static
 Var Flash::GetProxyForURL(const InstanceHandle& instance,
                           const std::string& url) {
   Var rv;
-  if (has_interface<PPB_Flash>()) {
+  if (has_interface<PPB_Flash_12_2>()) {
     rv = Var(PASS_REF,
-             get_interface<PPB_Flash>()->GetProxyForURL(instance.pp_instance(),
-                                                        url.c_str()));
+             get_interface<PPB_Flash_12_2>()->GetProxyForURL(
+                 instance.pp_instance(), url.c_str()));
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = Var(PASS_REF,
+             get_interface<PPB_Flash_12_1>()->GetProxyForURL(
+                 instance.pp_instance(), url.c_str()));
   } else if (has_interface<PPB_Flash_12_0>()) {
     rv = Var(PASS_REF,
              get_interface<PPB_Flash_12_0>()->GetProxyForURL(
                  instance.pp_instance(), url.c_str()));
   } else if (has_interface<PPB_Flash_11>()) {
     rv = Var(PASS_REF,
              get_interface<PPB_Flash_11>()->GetProxyForURL(
                  instance.pp_instance(), url.c_str()));
   }
   return rv;
 }
 
 // static
 int32_t Flash::Navigate(const URLRequestInfo& request_info,
                         const std::string& target,
                         bool from_user_action) {
   int32_t rv = PP_ERROR_FAILED;
-  if (has_interface<PPB_Flash>()) {
-    rv = get_interface<PPB_Flash>()->Navigate(request_info.pp_resource(),
-                                              target.c_str(),
-                                              PP_FromBool(from_user_action));
+  if (has_interface<PPB_Flash_12_2>()) {
+    rv = get_interface<PPB_Flash_12_2>()->Navigate(
+        request_info.pp_resource(),
+        target.c_str(),
+        PP_FromBool(from_user_action));
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = get_interface<PPB_Flash_12_1>()->Navigate(
+        request_info.pp_resource(),
+        target.c_str(),
+        PP_FromBool(from_user_action));
   } else if (has_interface<PPB_Flash_12_0>()) {
     rv = get_interface<PPB_Flash_12_0>()->Navigate(
         request_info.pp_resource(),
         target.c_str(),
         PP_FromBool(from_user_action));
   } else if (has_interface<PPB_Flash_11>()) {
     rv = get_interface<PPB_Flash_11>()->Navigate(request_info.pp_resource(),
                                                  target.c_str(),
                                                  from_user_action);
   }
   return rv;
 }
 
 // static
 void Flash::RunMessageLoop(const InstanceHandle& instance) {
-  if (has_interface<PPB_Flash>())
-    get_interface<PPB_Flash>()->RunMessageLoop(instance.pp_instance());
+  if (has_interface<PPB_Flash_12_2>())
+    get_interface<PPB_Flash_12_2>()->RunMessageLoop(instance.pp_instance());
+  else if (has_interface<PPB_Flash_12_2>())
+    get_interface<PPB_Flash_12_2>()->RunMessageLoop(instance.pp_instance());
   else if (has_interface<PPB_Flash_12_0>())
     get_interface<PPB_Flash_12_0>()->RunMessageLoop(instance.pp_instance());
   else if (has_interface<PPB_Flash_11>())
     get_interface<PPB_Flash_11>()->RunMessageLoop(instance.pp_instance());
 }
 
 // static
 void Flash::QuitMessageLoop(const InstanceHandle& instance) {
-  if (has_interface<PPB_Flash>())
-    get_interface<PPB_Flash>()->QuitMessageLoop(instance.pp_instance());
+  if (has_interface<PPB_Flash_12_2>())
+    get_interface<PPB_Flash_12_2>()->QuitMessageLoop(instance.pp_instance());
+  else if (has_interface<PPB_Flash_12_1>())
+    get_interface<PPB_Flash_12_1>()->QuitMessageLoop(instance.pp_instance());
   else if (has_interface<PPB_Flash_12_0>())
     get_interface<PPB_Flash_12_0>()->QuitMessageLoop(instance.pp_instance());
   else if (has_interface<PPB_Flash_11>())
     get_interface<PPB_Flash_11>()->QuitMessageLoop(instance.pp_instance());
 }
 
 // static
 double Flash::GetLocalTimeZoneOffset(const InstanceHandle& instance,
                                      PP_Time t) {
   double rv = 0;
-  if (has_interface<PPB_Flash>()) {
-    rv = get_interface<PPB_Flash>()->GetLocalTimeZoneOffset(
+  if (has_interface<PPB_Flash_12_2>()) {
+    rv = get_interface<PPB_Flash_12_2>()->GetLocalTimeZoneOffset(
+        instance.pp_instance(), t);
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = get_interface<PPB_Flash_12_1>()->GetLocalTimeZoneOffset(
         instance.pp_instance(), t);
   } else if (has_interface<PPB_Flash_12_0>()) {
     rv = get_interface<PPB_Flash_12_0>()->GetLocalTimeZoneOffset(
         instance.pp_instance(), t);
   } else if (has_interface<PPB_Flash_11>()) {
     rv = get_interface<PPB_Flash_11>()->GetLocalTimeZoneOffset(
         instance.pp_instance(), t);
   }
   return rv;
 }
 
 // static
 Var Flash::GetCommandLineArgs(Module* module) {
   Var rv;
-  if (has_interface<PPB_Flash>()) {
+  if (has_interface<PPB_Flash_12_2>()) {
     rv = Var(PASS_REF,
-             get_interface<PPB_Flash>()->GetCommandLineArgs(
+             get_interface<PPB_Flash_12_2>()->GetCommandLineArgs(
+                 module->pp_module()));
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = Var(PASS_REF,
+             get_interface<PPB_Flash_12_1>()->GetCommandLineArgs(
                  module->pp_module()));
   } else if (has_interface<PPB_Flash_12_0>()) {
     rv = Var(PASS_REF,
              get_interface<PPB_Flash_12_0>()->GetCommandLineArgs(
                  module->pp_module()));
   } else if (has_interface<PPB_Flash_11>()) {
     rv = Var(PASS_REF,
              get_interface<PPB_Flash_11>()->GetCommandLineArgs(
                  module->pp_module()));
   }
   return rv;
 }
 
 // static
 void Flash::PreloadFontWin(const void* logfontw) {
-  if (has_interface<PPB_Flash>())
-    get_interface<PPB_Flash>()->PreloadFontWin(logfontw);
+  if (has_interface<PPB_Flash_12_2>())
+    get_interface<PPB_Flash_12_2>()->PreloadFontWin(logfontw);
+  else if (has_interface<PPB_Flash_12_1>())
+    get_interface<PPB_Flash_12_1>()->PreloadFontWin(logfontw);
   else if (has_interface<PPB_Flash_12_0>())
     get_interface<PPB_Flash_12_0>()->PreloadFontWin(logfontw);
 }
 
 // static
 bool Flash::IsRectTopmost(const InstanceHandle& instance, const Rect& rect) {
   bool rv = false;
-  if (has_interface<PPB_Flash>()) {
-    rv = PP_ToBool(get_interface<PPB_Flash>()->IsRectTopmost(
+  if (has_interface<PPB_Flash_12_2>()) {
+    rv = PP_ToBool(get_interface<PPB_Flash_12_2>()->IsRectTopmost(
+        instance.pp_instance(), &rect.pp_rect()));
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = PP_ToBool(get_interface<PPB_Flash_12_1>()->IsRectTopmost(
         instance.pp_instance(), &rect.pp_rect()));
   }
   return rv;
 }
 
 // static
 int32_t Flash::InvokePrinting(const InstanceHandle& instance) {
   int32_t rv = PP_ERROR_NOTSUPPORTED;
-  if (has_interface<PPB_Flash>())
-    rv = get_interface<PPB_Flash>()->InvokePrinting(instance.pp_instance());
+  if (has_interface<PPB_Flash_12_2>()) {
+    rv = get_interface<PPB_Flash_12_2>()->InvokePrinting(
+        instance.pp_instance());
+  } else if (has_interface<PPB_Flash_12_1>()) {
+    rv = get_interface<PPB_Flash_12_1>()->InvokePrinting(
+        instance.pp_instance());
+  }
   return rv;
 }
 
 // static
 void Flash::UpdateActivity(const InstanceHandle& instance) {
-  if (has_interface<PPB_Flash>())
-    get_interface<PPB_Flash>()->UpdateActivity(instance.pp_instance());
+  if (has_interface<PPB_Flash_12_2>())
+    get_interface<PPB_Flash_12_2>()->UpdateActivity(instance.pp_instance());
+  if (has_interface<PPB_Flash_12_1>())
+    get_interface<PPB_Flash_12_1>()->UpdateActivity(instance.pp_instance());
+}
+
+// static
+Var Flash::GetDeviceID(const InstanceHandle& instance) {
+  if (has_interface<PPB_Flash_12_2>()) {
+    return Var(
+        PASS_REF,
+        get_interface<PPB_Flash_12_2>()->GetDeviceID(instance.pp_instance()));
+  }
+  return Var();
 }
 
 }  // namespace flash
 }  // namespace pp