ppapi/thunk/ppb_flash_clipboard_thunk.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "ppapi/c/pp_errors.h"
   7 #include "ppapi/c/private/ppb_flash_clipboard.h"
   8 #include "ppapi/thunk/enter.h"
   9 #include "ppapi/thunk/ppb_flash_clipboard_api.h"
  10 #include "ppapi/thunk/thunk.h"
  11
  12 namespace ppapi {
  13 namespace thunk {
  14
  15 namespace {
  16
  17 uint32_t RegisterCustomFormat(PP_Instance instance,
  18                               const char* format_name) {
  19   EnterInstance enter(instance);
  20   if (enter.failed())
  21     return PP_FALSE;
  22   return enter.functions()->GetFlashClipboardAPI(
  23       instance)->RegisterCustomFormat(instance, format_name);
  24 }
  25
  26 PP_Bool IsFormatAvailable(PP_Instance instance,
  27                           PP_Flash_Clipboard_Type clipboard_type,
  28                           uint32_t format) {
  29   EnterInstance enter(instance);
  30   if (enter.failed())
  31     return PP_FALSE;
  32   return enter.functions()->GetFlashClipboardAPI(
  33       instance)->IsFormatAvailable(instance, clipboard_type, format);
  34 }
  35
  36 PP_Var ReadData(PP_Instance instance,
  37                 PP_Flash_Clipboard_Type clipboard_type,
  38                 uint32_t format) {
  39   EnterInstance enter(instance);
  40   if (enter.failed())
  41     return PP_MakeUndefined();
  42   return enter.functions()->GetFlashClipboardAPI(instance)->ReadData(
  43       instance, clipboard_type, format);
  44 }
  45
  46 int32_t WriteData(PP_Instance instance,
  47                   PP_Flash_Clipboard_Type clipboard_type,
  48                   uint32_t data_item_count,
  49                   const uint32_t formats[],
  50                   const PP_Var data_items[]) {
  51   EnterInstance enter(instance);
  52   if (enter.failed())
  53     return enter.retval();
  54   return enter.functions()->GetFlashClipboardAPI(instance)->WriteData(
  55       instance, clipboard_type, data_item_count, formats, data_items);
  56 }
  57
  58 PP_Bool IsFormatAvailable_4_0(PP_Instance instance,
  59                               PP_Flash_Clipboard_Type clipboard_type,
  60                               PP_Flash_Clipboard_Format format) {
  61   return IsFormatAvailable(instance, clipboard_type,
  62                            static_cast<uint32_t>(format));
  63 }
  64
  65 PP_Var ReadData_4_0(PP_Instance instance,
  66                     PP_Flash_Clipboard_Type clipboard_type,
  67                     PP_Flash_Clipboard_Format format) {
  68   return ReadData(instance, clipboard_type, static_cast<uint32_t>(format));
  69 }
  70
  71 int32_t WriteData_4_0(PP_Instance instance,
  72                       PP_Flash_Clipboard_Type clipboard_type,
  73                       uint32_t data_item_count,
  74                       const PP_Flash_Clipboard_Format formats[],
  75                       const PP_Var data_items[]) {
  76   scoped_array<uint32_t> new_formats(new uint32_t[data_item_count]);
  77   for (uint32_t i = 0; i < data_item_count; ++i)
  78     new_formats[i] = static_cast<uint32_t>(formats[i]);
  79   return WriteData(instance, clipboard_type, data_item_count,
  80                    new_formats.get(), data_items);
  81 }
  82
  83 const PPB_Flash_Clipboard_4_0 g_ppb_flash_clipboard_thunk_4_0 = {
  84   &IsFormatAvailable_4_0,
  85   &ReadData_4_0,
  86   &WriteData_4_0
  87 };
  88
  89 const PPB_Flash_Clipboard_5_0 g_ppb_flash_clipboard_thunk_5_0 = {
  90   &RegisterCustomFormat,
  91   &IsFormatAvailable,
  92   &ReadData,
  93   &WriteData
  94 };
  95
  96 }  // namespace
  97
  98 const PPB_Flash_Clipboard_4_0* GetPPB_Flash_Clipboard_4_0_Thunk() {
  99   return &g_ppb_flash_clipboard_thunk_4_0;
 100 }
 101
 102 const PPB_Flash_Clipboard_5_0* GetPPB_Flash_Clipboard_5_0_Thunk() {
 103   return &g_ppb_flash_clipboard_thunk_5_0;
 104 }
 105
 106 }  // namespace thunk
 107 }  // namespace ppapi