ppapi/cpp/private/flash_clipboard.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 "ppapi/cpp/private/flash_clipboard.h"
   6
   7 #include <vector>
   8
   9 #include "ppapi/c/pp_bool.h"
  10 #include "ppapi/c/pp_errors.h"
  11 #include "ppapi/cpp/instance_handle.h"
  12 #include "ppapi/cpp/module_impl.h"
  13 #include "ppapi/cpp/var.h"
  14
  15 namespace pp {
  16
  17 namespace {
  18
  19 template <> const char* interface_name<PPB_Flash_Clipboard_4_0>() {
  20   return PPB_FLASH_CLIPBOARD_INTERFACE_4_0;
  21 }
  22
  23 template <> const char* interface_name<PPB_Flash_Clipboard_5_0>() {
  24   return PPB_FLASH_CLIPBOARD_INTERFACE_5_0;
  25 }
  26
  27 }  // namespace
  28
  29 namespace flash {
  30
  31 // static
  32 bool Clipboard::IsAvailable() {
  33   return has_interface<PPB_Flash_Clipboard_5_0>() ||
  34       has_interface<PPB_Flash_Clipboard_4_0>() ;
  35 }
  36
  37 // static
  38 uint32_t Clipboard::RegisterCustomFormat(const InstanceHandle& instance,
  39                                          const std::string& format_name) {
  40   uint32_t rv = PP_FLASH_CLIPBOARD_FORMAT_INVALID;
  41   if (has_interface<PPB_Flash_Clipboard_5_0>()) {
  42     rv = get_interface<PPB_Flash_Clipboard_5_0>()->RegisterCustomFormat(
  43         instance.pp_instance(), format_name.c_str());
  44   }
  45   return rv;
  46 }
  47
  48 // static
  49 bool Clipboard::IsFormatAvailable(const InstanceHandle& instance,
  50                                   PP_Flash_Clipboard_Type clipboard_type,
  51                                   uint32_t format) {
  52   bool rv = false;
  53   if (has_interface<PPB_Flash_Clipboard_5_0>()) {
  54     rv = PP_ToBool(get_interface<PPB_Flash_Clipboard_5_0>()->IsFormatAvailable(
  55         instance.pp_instance(), clipboard_type, format));
  56   } else if (has_interface<PPB_Flash_Clipboard_4_0>()) {
  57     rv = PP_ToBool(get_interface<PPB_Flash_Clipboard_4_0>()->IsFormatAvailable(
  58         instance.pp_instance(), clipboard_type,
  59         static_cast<PP_Flash_Clipboard_Format>(format)));
  60   }
  61   return rv;
  62 }
  63
  64 // static
  65 bool Clipboard::ReadData(
  66     const InstanceHandle& instance,
  67     PP_Flash_Clipboard_Type clipboard_type,
  68     uint32_t format,
  69     Var* out) {
  70   bool rv = false;
  71   if (has_interface<PPB_Flash_Clipboard_5_0>()) {
  72     PP_Var result = get_interface<PPB_Flash_Clipboard_5_0>()->ReadData(
  73         instance.pp_instance(),
  74         clipboard_type,
  75         format);
  76     *out = Var(PASS_REF, result);
  77     rv = true;
  78   } else if (has_interface<PPB_Flash_Clipboard_4_0>()) {
  79     PP_Var result = get_interface<PPB_Flash_Clipboard_4_0>()->ReadData(
  80         instance.pp_instance(),
  81         clipboard_type,
  82         static_cast<PP_Flash_Clipboard_Format>(format));
  83     *out = Var(PASS_REF, result);
  84     rv = true;
  85   }
  86   return rv;
  87 }
  88
  89 // static
  90 bool Clipboard::WriteData(
  91     const InstanceHandle& instance,
  92     PP_Flash_Clipboard_Type clipboard_type,
  93     const std::vector<uint32_t>& formats,
  94     const std::vector<Var>& data_items) {
  95   if (formats.size() != data_items.size())
  96     return false;
  97
  98   bool rv = false;
  99   if (has_interface<PPB_Flash_Clipboard_5_0>()) {
 100     // Convert vector of pp::Var into a vector of PP_Var.
 101     std::vector<PP_Var> data_items_vector;
 102     for (uint32_t i = 0; i < data_items.size(); ++i)
 103       data_items_vector.push_back(data_items[i].pp_var());
 104
 105     // Ensure that we don't dereference the memory in empty vectors. We still
 106     // want to call WriteData because it has the effect of clearing the
 107     // clipboard.
 108     const uint32_t* formats_ptr(NULL);
 109     const PP_Var* data_items_ptr(NULL);
 110     if (data_items.size() > 0) {
 111       formats_ptr = &formats[0];
 112       data_items_ptr = &data_items_vector[0];
 113     }
 114
 115     rv = (get_interface<PPB_Flash_Clipboard_5_0>()->WriteData(
 116         instance.pp_instance(),
 117         clipboard_type,
 118         data_items.size(),
 119         formats_ptr,
 120         data_items_ptr) == PP_OK);
 121   } else if (has_interface<PPB_Flash_Clipboard_4_0>()) {
 122     // Convert vector of pp::Var into a vector of PP_Var.
 123     std::vector<PP_Var> data_items_vector;
 124     std::vector<PP_Flash_Clipboard_Format> old_formats;
 125     for (uint32_t i = 0; i < data_items.size(); ++i) {
 126       data_items_vector.push_back(data_items[i].pp_var());
 127       old_formats.push_back(static_cast<PP_Flash_Clipboard_Format>(formats[i]));
 128     }
 129
 130     // Ensure that we don't dereference the memory in empty vectors. We still
 131     // want to call WriteData because it has the effect of clearing the
 132     // clipboard.
 133     const PP_Flash_Clipboard_Format* formats_ptr(NULL);
 134     const PP_Var* data_items_ptr(NULL);
 135     if (data_items.size() > 0) {
 136       formats_ptr = &old_formats[0];
 137       data_items_ptr = &data_items_vector[0];
 138     }
 139
 140     rv = (get_interface<PPB_Flash_Clipboard_4_0>()->WriteData(
 141         instance.pp_instance(),
 142         clipboard_type,
 143         data_items.size(),
 144         formats_ptr,
 145         data_items_ptr) == PP_OK);
 146   }
 147
 148   return rv;
 149 }
 150
 151 }  // namespace flash
 152 }  // namespace pp