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