OLD | NEW |
(Empty) | |
| 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 "content/renderer/pepper/pepper_flash_clipboard_host.h" |
| 6 |
| 7 #include "base/pickle.h" |
| 8 #include "base/utf_string_conversions.h" |
| 9 #include "content/public/renderer/renderer_ppapi_host.h" |
| 10 #include "content/renderer/renderer_clipboard_client.h" |
| 11 #include "ipc/ipc_message_macros.h" |
| 12 #include "ppapi/c/pp_errors.h" |
| 13 #include "ppapi/c/private/ppb_flash_clipboard.h" |
| 14 #include "ppapi/host/dispatch_host_message.h" |
| 15 #include "ppapi/host/ppapi_host.h" |
| 16 #include "ppapi/proxy/ppapi_messages.h" |
| 17 #include "ppapi/proxy/resource_message_params.h" |
| 18 #include "webkit/glue/clipboard_client.h" |
| 19 #include "webkit/glue/scoped_clipboard_writer_glue.h" |
| 20 |
| 21 namespace content { |
| 22 |
| 23 namespace { |
| 24 |
| 25 const size_t kMaxClipboardWriteSize = 1000000; |
| 26 |
| 27 ui::Clipboard::Buffer ConvertClipboardType(uint32_t type) { |
| 28 switch (type) { |
| 29 case PP_FLASH_CLIPBOARD_TYPE_STANDARD: |
| 30 return ui::Clipboard::BUFFER_STANDARD; |
| 31 case PP_FLASH_CLIPBOARD_TYPE_SELECTION: |
| 32 return ui::Clipboard::BUFFER_SELECTION; |
| 33 } |
| 34 NOTREACHED(); |
| 35 return ui::Clipboard::BUFFER_STANDARD; |
| 36 } |
| 37 |
| 38 // Functions to pack/unpack custom data from a pickle. See the header file for |
| 39 // more detail on custom formats in Pepper. |
| 40 // TODO(raymes): Currently pepper custom formats are stored in their own |
| 41 // native format type. However we should be able to store them in the same way |
| 42 // as "Web Custom" formats are. This would allow clipboard data to be shared |
| 43 // between pepper applications and web applications. However currently web apps |
| 44 // assume all data that is placed on the clipboard is UTF16 and pepper allows |
| 45 // arbitrary data so this change would require some reworking of the chrome |
| 46 // clipboard interface for custom data. |
| 47 bool JumpToFormatInPickle(const string16& format, PickleIterator* iter) { |
| 48 uint64 size = 0; |
| 49 if (!iter->ReadUInt64(&size)) |
| 50 return false; |
| 51 for (uint64 i = 0; i < size; ++i) { |
| 52 string16 stored_format; |
| 53 if (!iter->ReadString16(&stored_format)) |
| 54 return false; |
| 55 if (stored_format == format) |
| 56 return true; |
| 57 int skip_length; |
| 58 if (!iter->ReadLength(&skip_length)) |
| 59 return false; |
| 60 if (!iter->SkipBytes(skip_length)) |
| 61 return false; |
| 62 } |
| 63 return false; |
| 64 } |
| 65 |
| 66 bool IsFormatAvailableInPickle(const string16& format, const Pickle& pickle) { |
| 67 PickleIterator iter(pickle); |
| 68 return JumpToFormatInPickle(format, &iter); |
| 69 } |
| 70 |
| 71 std::string ReadDataFromPickle(const string16& format, const Pickle& pickle) { |
| 72 std::string result; |
| 73 PickleIterator iter(pickle); |
| 74 if (!JumpToFormatInPickle(format, &iter) || !iter.ReadString(&result)) |
| 75 return std::string(); |
| 76 return result; |
| 77 } |
| 78 |
| 79 bool WriteDataToPickle(const std::map<string16, std::string>& data, |
| 80 Pickle* pickle) { |
| 81 pickle->WriteUInt64(data.size()); |
| 82 for (std::map<string16, std::string>::const_iterator it = data.begin(); |
| 83 it != data.end(); ++it) { |
| 84 if (!pickle->WriteString16(it->first)) |
| 85 return false; |
| 86 if (!pickle->WriteString(it->second)) |
| 87 return false; |
| 88 } |
| 89 return true; |
| 90 } |
| 91 |
| 92 } // namespace |
| 93 |
| 94 PepperFlashClipboardHost::PepperFlashClipboardHost( |
| 95 RendererPpapiHost* host, |
| 96 PP_Instance instance, |
| 97 PP_Resource resource) |
| 98 : ResourceHost(host->GetPpapiHost(), instance, resource), |
| 99 clipboard_client_(new RendererClipboardClient) { |
| 100 } |
| 101 |
| 102 PepperFlashClipboardHost::~PepperFlashClipboardHost() { |
| 103 } |
| 104 |
| 105 int32_t PepperFlashClipboardHost::OnResourceMessageReceived( |
| 106 const IPC::Message& msg, |
| 107 ppapi::host::HostMessageContext* context) { |
| 108 IPC_BEGIN_MESSAGE_MAP(PepperFlashClipboardHost, msg) |
| 109 PPAPI_DISPATCH_HOST_RESOURCE_CALL( |
| 110 PpapiHostMsg_FlashClipboard_RegisterCustomFormat, |
| 111 OnMsgRegisterCustomFormat); |
| 112 PPAPI_DISPATCH_HOST_RESOURCE_CALL( |
| 113 PpapiHostMsg_FlashClipboard_IsFormatAvailable, |
| 114 OnMsgIsFormatAvailable); |
| 115 PPAPI_DISPATCH_HOST_RESOURCE_CALL( |
| 116 PpapiHostMsg_FlashClipboard_ReadData, |
| 117 OnMsgReadData); |
| 118 PPAPI_DISPATCH_HOST_RESOURCE_CALL( |
| 119 PpapiHostMsg_FlashClipboard_WriteData, |
| 120 OnMsgWriteData); |
| 121 IPC_END_MESSAGE_MAP() |
| 122 return PP_ERROR_FAILED; |
| 123 } |
| 124 |
| 125 int32_t PepperFlashClipboardHost::OnMsgRegisterCustomFormat( |
| 126 ppapi::host::HostMessageContext* host_context, |
| 127 const std::string& format_name) { |
| 128 uint32_t format = custom_formats_.RegisterFormat(format_name); |
| 129 if (format == PP_FLASH_CLIPBOARD_FORMAT_INVALID) |
| 130 return PP_ERROR_FAILED; |
| 131 host_context->reply_msg = |
| 132 PpapiPluginMsg_FlashClipboard_RegisterCustomFormatReply(format); |
| 133 return PP_OK; |
| 134 } |
| 135 |
| 136 int32_t PepperFlashClipboardHost::OnMsgIsFormatAvailable( |
| 137 ppapi::host::HostMessageContext* host_context, |
| 138 uint32_t clipboard_type, |
| 139 uint32_t format) { |
| 140 if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) { |
| 141 NOTIMPLEMENTED(); |
| 142 return PP_ERROR_FAILED; |
| 143 } |
| 144 |
| 145 ui::Clipboard::Buffer buffer_type = ConvertClipboardType(clipboard_type); |
| 146 bool available = false; |
| 147 switch (format) { |
| 148 case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: { |
| 149 bool plain = clipboard_client_->IsFormatAvailable( |
| 150 ui::Clipboard::GetPlainTextFormatType(), buffer_type); |
| 151 bool plainw = clipboard_client_->IsFormatAvailable( |
| 152 ui::Clipboard::GetPlainTextWFormatType(), buffer_type); |
| 153 available = plain || plainw; |
| 154 break; |
| 155 } |
| 156 case PP_FLASH_CLIPBOARD_FORMAT_HTML: |
| 157 available = clipboard_client_->IsFormatAvailable( |
| 158 ui::Clipboard::GetHtmlFormatType(), buffer_type); |
| 159 break; |
| 160 case PP_FLASH_CLIPBOARD_FORMAT_RTF: |
| 161 available = clipboard_client_->IsFormatAvailable( |
| 162 ui::Clipboard::GetRtfFormatType(), buffer_type); |
| 163 break; |
| 164 case PP_FLASH_CLIPBOARD_FORMAT_INVALID: |
| 165 break; |
| 166 default: |
| 167 if (custom_formats_.IsFormatRegistered(format)) { |
| 168 std::string format_name = custom_formats_.GetFormatName(format); |
| 169 std::string clipboard_data; |
| 170 clipboard_client_->ReadData( |
| 171 ui::Clipboard::GetPepperCustomDataFormatType(), &clipboard_data); |
| 172 Pickle pickle(clipboard_data.data(), clipboard_data.size()); |
| 173 available = IsFormatAvailableInPickle(UTF8ToUTF16(format_name), pickle); |
| 174 } |
| 175 break; |
| 176 } |
| 177 |
| 178 return available ? PP_OK : PP_ERROR_FAILED; |
| 179 } |
| 180 |
| 181 int32_t PepperFlashClipboardHost::OnMsgReadData( |
| 182 ppapi::host::HostMessageContext* host_context, |
| 183 uint32_t clipboard_type, |
| 184 uint32_t format) { |
| 185 if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) { |
| 186 NOTIMPLEMENTED(); |
| 187 return PP_ERROR_FAILED; |
| 188 } |
| 189 |
| 190 ui::Clipboard::Buffer buffer_type = ConvertClipboardType(clipboard_type); |
| 191 std::string clipboard_string; |
| 192 int32_t result = PP_ERROR_FAILED; |
| 193 switch (format) { |
| 194 case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: { |
| 195 if (clipboard_client_->IsFormatAvailable( |
| 196 ui::Clipboard::GetPlainTextWFormatType(), buffer_type)) { |
| 197 string16 text; |
| 198 clipboard_client_->ReadText(buffer_type, &text); |
| 199 if (!text.empty()) { |
| 200 result = PP_OK; |
| 201 clipboard_string = UTF16ToUTF8(text); |
| 202 break; |
| 203 } |
| 204 } |
| 205 // If the PlainTextW format isn't available or is empty, take the |
| 206 // ASCII text format. |
| 207 if (clipboard_client_->IsFormatAvailable( |
| 208 ui::Clipboard::GetPlainTextFormatType(), buffer_type)) { |
| 209 result = PP_OK; |
| 210 clipboard_client_->ReadAsciiText(buffer_type, &clipboard_string); |
| 211 } |
| 212 break; |
| 213 } |
| 214 case PP_FLASH_CLIPBOARD_FORMAT_HTML: { |
| 215 if (!clipboard_client_->IsFormatAvailable( |
| 216 ui::Clipboard::GetHtmlFormatType(), buffer_type)) { |
| 217 break; |
| 218 } |
| 219 |
| 220 string16 html; |
| 221 GURL gurl; |
| 222 uint32 fragment_start; |
| 223 uint32 fragment_end; |
| 224 clipboard_client_->ReadHTML(buffer_type, &html, &gurl, &fragment_start, |
| 225 &fragment_end); |
| 226 result = PP_OK; |
| 227 clipboard_string = UTF16ToUTF8( |
| 228 html.substr(fragment_start, fragment_end - fragment_start)); |
| 229 break; |
| 230 } |
| 231 case PP_FLASH_CLIPBOARD_FORMAT_RTF: { |
| 232 if (!clipboard_client_->IsFormatAvailable( |
| 233 ui::Clipboard::GetRtfFormatType(), buffer_type)) { |
| 234 break; |
| 235 } |
| 236 result = PP_OK; |
| 237 clipboard_client_->ReadRTF(buffer_type, &clipboard_string); |
| 238 break; |
| 239 } |
| 240 case PP_FLASH_CLIPBOARD_FORMAT_INVALID: |
| 241 break; |
| 242 default: { |
| 243 if (custom_formats_.IsFormatRegistered(format)) { |
| 244 string16 format_name = UTF8ToUTF16( |
| 245 custom_formats_.GetFormatName(format)); |
| 246 std::string clipboard_data; |
| 247 clipboard_client_->ReadData( |
| 248 ui::Clipboard::GetPepperCustomDataFormatType(), &clipboard_data); |
| 249 Pickle pickle(clipboard_data.data(), clipboard_data.size()); |
| 250 if (IsFormatAvailableInPickle(format_name, pickle)) { |
| 251 result = PP_OK; |
| 252 clipboard_string = ReadDataFromPickle(format_name, pickle); |
| 253 } |
| 254 } |
| 255 break; |
| 256 } |
| 257 } |
| 258 |
| 259 if (result == PP_OK) { |
| 260 host_context->reply_msg = |
| 261 PpapiPluginMsg_FlashClipboard_ReadDataReply(clipboard_string); |
| 262 } |
| 263 return result; |
| 264 } |
| 265 |
| 266 int32_t PepperFlashClipboardHost::OnMsgWriteData( |
| 267 ppapi::host::HostMessageContext* host_context, |
| 268 uint32_t clipboard_type, |
| 269 const std::vector<uint32_t>& formats, |
| 270 const std::vector<std::string>& data) { |
| 271 if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) { |
| 272 NOTIMPLEMENTED(); |
| 273 return PP_ERROR_FAILED; |
| 274 } |
| 275 |
| 276 DCHECK(formats.size() == data.size()); |
| 277 // If no formats are passed in clear the clipboard. |
| 278 if (formats.size() == 0) { |
| 279 clipboard_client_->Clear(ConvertClipboardType(clipboard_type)); |
| 280 return PP_OK; |
| 281 } |
| 282 |
| 283 webkit_glue::ScopedClipboardWriterGlue scw(clipboard_client_.get()); |
| 284 std::map<string16, std::string> custom_data_map; |
| 285 int32_t res = PP_OK; |
| 286 for (uint32_t i = 0; i < formats.size(); ++i) { |
| 287 if (data[i].length() > kMaxClipboardWriteSize) { |
| 288 res = PP_ERROR_NOSPACE; |
| 289 break; |
| 290 } |
| 291 |
| 292 switch (formats[i]) { |
| 293 case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: |
| 294 scw.WriteText(UTF8ToUTF16(data[i])); |
| 295 break; |
| 296 case PP_FLASH_CLIPBOARD_FORMAT_HTML: |
| 297 scw.WriteHTML(UTF8ToUTF16(data[i]), ""); |
| 298 break; |
| 299 case PP_FLASH_CLIPBOARD_FORMAT_RTF: |
| 300 scw.WriteRTF(data[i]); |
| 301 break; |
| 302 case PP_FLASH_CLIPBOARD_FORMAT_INVALID: |
| 303 res = PP_ERROR_BADARGUMENT; |
| 304 break; |
| 305 default: |
| 306 if (custom_formats_.IsFormatRegistered(formats[i])) { |
| 307 std::string format_name = custom_formats_.GetFormatName(formats[i]); |
| 308 custom_data_map[UTF8ToUTF16(format_name)] = data[i]; |
| 309 } else { |
| 310 // Invalid format. |
| 311 res = PP_ERROR_BADARGUMENT; |
| 312 break; |
| 313 } |
| 314 } |
| 315 |
| 316 if (res != PP_OK) |
| 317 break; |
| 318 } |
| 319 |
| 320 if (custom_data_map.size() > 0) { |
| 321 Pickle pickle; |
| 322 if (WriteDataToPickle(custom_data_map, &pickle)) { |
| 323 scw.WritePickledData(pickle, |
| 324 ui::Clipboard::GetPepperCustomDataFormatType()); |
| 325 } else { |
| 326 res = PP_ERROR_BADARGUMENT; |
| 327 } |
| 328 } |
| 329 |
| 330 if (res != PP_OK) { |
| 331 // Need to clear the objects so nothing is written. |
| 332 scw.Reset(); |
| 333 } |
| 334 |
| 335 return res; |
| 336 } |
| 337 |
| 338 } // namespace content |
| 339 |
OLD | NEW |