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 "ui/base/clipboard/clipboard.h"
6
7 #include <list>
8
9 #include "base/basictypes.h"
10 #include "base/files/file_path.h"
11 #include "base/logging.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/stl_util.h"
14 #include "base/strings/utf_string_conversions.h"
15 #include "third_party/skia/include/core/SkBitmap.h"
16 #include "ui/base/clipboard/custom_data_helper.h"
17 #include "ui/gfx/size.h"
18
19 namespace ui {
20
21 namespace {
22 const char kMimeTypeFilename[] = "chromium/filename";
23 const char kMimeTypeBitmap[] = "image/bmp";
24 const char kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";
25 const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
26 const size_t kMaxClipboardSize = 1;
27
28 // Clipboard data format used by AuraClipboard.
29 enum AuraClipboardFormat {
30 TEXT = 1 << 0,
31 HTML = 1 << 1,
32 RTF = 1 << 2,
33 BOOKMARK = 1 << 3,
34 BITMAP = 1 << 4,
35 CUSTOM = 1 << 5,
36 WEB = 1 << 6,
37 };
38
39 // ClipboardData contains data copied to the Clipboard for a variety of formats.
40 // It mostly just provides APIs to cleanly access and manipulate this data.
41 class ClipboardData {
42 public:
ClipboardData()43 ClipboardData()
44 : web_smart_paste_(false),
45 format_(0) {}
46
~ClipboardData()47 virtual ~ClipboardData() {}
48
49 // Bitmask of AuraClipboardFormat types.
format() const50 const int format() const { return format_; }
51
text() const52 const std::string& text() const { return text_; }
set_text(const std::string & text)53 void set_text(const std::string& text) {
54 text_ = text;
55 format_ |= TEXT;
56 }
57
markup_data() const58 const std::string& markup_data() const { return markup_data_; }
set_markup_data(const std::string & markup_data)59 void set_markup_data(const std::string& markup_data) {
60 markup_data_ = markup_data;
61 format_ |= HTML;
62 }
63
rtf_data() const64 const std::string& rtf_data() const { return rtf_data_; }
SetRTFData(const std::string & rtf_data)65 void SetRTFData(const std::string& rtf_data) {
66 rtf_data_ = rtf_data;
67 format_ |= RTF;
68 }
69
url() const70 const std::string& url() const { return url_; }
set_url(const std::string & url)71 void set_url(const std::string& url) {
72 url_ = url;
73 format_ |= HTML;
74 }
75
bookmark_title() const76 const std::string& bookmark_title() const { return bookmark_title_; }
set_bookmark_title(const std::string & bookmark_title)77 void set_bookmark_title(const std::string& bookmark_title) {
78 bookmark_title_ = bookmark_title;
79 format_ |= BOOKMARK;
80 }
81
bookmark_url() const82 const std::string& bookmark_url() const { return bookmark_url_; }
set_bookmark_url(const std::string & bookmark_url)83 void set_bookmark_url(const std::string& bookmark_url) {
84 bookmark_url_ = bookmark_url;
85 format_ |= BOOKMARK;
86 }
87
bitmap() const88 const SkBitmap& bitmap() const { return bitmap_; }
SetBitmapData(const SkBitmap & bitmap)89 void SetBitmapData(const SkBitmap& bitmap) {
90 bitmap.copyTo(&bitmap_, bitmap.getConfig());
91 format_ |= BITMAP;
92 }
93
custom_data_format() const94 const std::string& custom_data_format() const { return custom_data_format_; }
custom_data_data() const95 const std::string& custom_data_data() const { return custom_data_data_; }
SetCustomData(const std::string & data_format,const std::string & data_data)96 void SetCustomData(const std::string& data_format,
97 const std::string& data_data) {
98 if (data_data.size() == 0) {
99 custom_data_data_.clear();
100 custom_data_format_.clear();
101 return;
102 }
103 custom_data_data_ = data_data;
104 custom_data_format_ = data_format;
105 format_ |= CUSTOM;
106 }
107
web_smart_paste() const108 bool web_smart_paste() const { return web_smart_paste_; }
set_web_smart_paste(bool web_smart_paste)109 void set_web_smart_paste(bool web_smart_paste) {
110 web_smart_paste_ = web_smart_paste;
111 format_ |= WEB;
112 }
113
114 private:
115 // Plain text in UTF8 format.
116 std::string text_;
117
118 // HTML markup data in UTF8 format.
119 std::string markup_data_;
120 std::string url_;
121
122 // RTF data.
123 std::string rtf_data_;
124
125 // Bookmark title in UTF8 format.
126 std::string bookmark_title_;
127 std::string bookmark_url_;
128
129 // Filenames.
130 std::vector<std::string> files_;
131
132 // Bitmap images.
133 SkBitmap bitmap_;
134
135 // Data with custom format.
136 std::string custom_data_format_;
137 std::string custom_data_data_;
138
139 // WebKit smart paste data.
140 bool web_smart_paste_;
141
142 int format_;
143
144 DISALLOW_COPY_AND_ASSIGN(ClipboardData);
145 };
146
147 // Platform clipboard implementation for Aura. This handles things like format
148 // conversion, versioning of clipboard items etc. The goal is to roughly provide
149 // a substitute to platform clipboards on other platforms such as GtkClipboard
150 // on gtk or winapi clipboard on win.
151 class AuraClipboard {
152 public:
AuraClipboard()153 AuraClipboard() {}
154
~AuraClipboard()155 ~AuraClipboard() {
156 Clear();
157 }
158
Clear()159 void Clear() {
160 STLDeleteContainerPointers(data_list_.begin(), data_list_.end());
161 data_list_.clear();
162 }
163
164 // Returns the number of entries currently in the clipboard stack.
GetNumClipboardEntries()165 size_t GetNumClipboardEntries() {
166 return data_list_.size();
167 }
168
169 // Returns the data currently on the top of the clipboard stack, NULL if the
170 // clipboard stack is empty.
GetData() const171 const ClipboardData* GetData() const {
172 if (data_list_.empty())
173 return NULL;
174 return data_list_.front();
175 }
176
177 // Returns true if the data on top of the clipboard stack has format |format|
178 // or another format that can be converted to |format|.
IsFormatAvailable(AuraClipboardFormat format) const179 bool IsFormatAvailable(AuraClipboardFormat format) const {
180 switch (format) {
181 case TEXT:
182 return HasFormat(TEXT) || HasFormat(BOOKMARK);
183 default:
184 return HasFormat(format);
185 }
186 }
187
188 // Reads text from the data at the top of clipboard stack.
ReadText(string16 * result) const189 void ReadText(string16* result) const {
190 std::string utf8_result;
191 ReadAsciiText(&utf8_result);
192 *result = UTF8ToUTF16(utf8_result);
193 }
194
195 // Reads ascii text from the data at the top of clipboard stack.
ReadAsciiText(std::string * result) const196 void ReadAsciiText(std::string* result) const {
197 result->clear();
198 const ClipboardData* data = GetData();
199 if (!data)
200 return;
201 if (HasFormat(TEXT))
202 *result = data->text();
203 else if (HasFormat(HTML))
204 *result = data->markup_data();
205 else if (HasFormat(BOOKMARK))
206 *result = data->bookmark_url();
207 }
208
209 // Reads HTML from the data at the top of clipboard stack.
ReadHTML(string16 * markup,std::string * src_url,uint32 * fragment_start,uint32 * fragment_end) const210 void ReadHTML(string16* markup,
211 std::string* src_url,
212 uint32* fragment_start,
213 uint32* fragment_end) const {
214 markup->clear();
215 if (src_url)
216 src_url->clear();
217 *fragment_start = 0;
218 *fragment_end = 0;
219
220 if (!HasFormat(HTML))
221 return;
222
223 const ClipboardData* data = GetData();
224 *markup = UTF8ToUTF16(data->markup_data());
225 *src_url = data->url();
226
227 *fragment_start = 0;
228 DCHECK_LE(markup->length(), kuint32max);
229 *fragment_end = static_cast<uint32>(markup->length());
230 }
231
232 // Reads RTF from the data at the top of clipboard stack.
ReadRTF(std::string * result) const233 void ReadRTF(std::string* result) const {
234 result->clear();
235 const ClipboardData* data = GetData();
236 if (!HasFormat(RTF))
237 return;
238
239 *result = data->rtf_data();
240 }
241
242 // Reads image from the data at the top of clipboard stack.
ReadImage() const243 SkBitmap ReadImage() const {
244 SkBitmap img;
245 if (!HasFormat(BITMAP))
246 return img;
247
248 // A shallow copy should be fine here, but just to be safe...
249 const SkBitmap& clipboard_bitmap = GetData()->bitmap();
250 clipboard_bitmap.copyTo(&img, clipboard_bitmap.getConfig());
251 return img;
252 }
253
254 // Reads data of type |type| from the data at the top of clipboard stack.
ReadCustomData(const string16 & type,string16 * result) const255 void ReadCustomData(const string16& type, string16* result) const {
256 result->clear();
257 const ClipboardData* data = GetData();
258 if (!HasFormat(CUSTOM))
259 return;
260
261 ui::ReadCustomDataForType(data->custom_data_data().c_str(),
262 data->custom_data_data().size(),
263 type, result);
264 }
265
266 // Reads bookmark from the data at the top of clipboard stack.
ReadBookmark(string16 * title,std::string * url) const267 void ReadBookmark(string16* title, std::string* url) const {
268 title->clear();
269 url->clear();
270 if (!HasFormat(BOOKMARK))
271 return;
272
273 const ClipboardData* data = GetData();
274 *title = UTF8ToUTF16(data->bookmark_title());
275 *url = data->bookmark_url();
276 }
277
ReadData(const std::string & type,std::string * result) const278 void ReadData(const std::string& type, std::string* result) const {
279 result->clear();
280 const ClipboardData* data = GetData();
281 if (!HasFormat(CUSTOM) || type != data->custom_data_format())
282 return;
283
284 *result = data->custom_data_data();
285 }
286
287 // Writes |data| to the top of the clipboard stack.
WriteData(ClipboardData * data)288 void WriteData(ClipboardData* data) {
289 DCHECK(data);
290 AddToListEnsuringSize(data);
291 }
292
293 private:
294 // True if the data on top of the clipboard stack has format |format|.
HasFormat(AuraClipboardFormat format) const295 bool HasFormat(AuraClipboardFormat format) const {
296 const ClipboardData* data = GetData();
297 if (!data)
298 return false;
299
300 return data->format() & format;
301 }
302
AddToListEnsuringSize(ClipboardData * data)303 void AddToListEnsuringSize(ClipboardData* data) {
304 DCHECK(data);
305 data_list_.push_front(data);
306
307 // If the size of list becomes more than the maximum allowed, we delete the
308 // last element.
309 if (data_list_.size() > kMaxClipboardSize) {
310 ClipboardData* last = data_list_.back();
311 data_list_.pop_back();
312 delete last;
313 }
314 }
315
316 // Stack containing various versions of ClipboardData.
317 std::list<ClipboardData*> data_list_;
318
319 DISALLOW_COPY_AND_ASSIGN(AuraClipboard);
320 };
321
322 AuraClipboard* aura_clipboard = NULL;
323
GetClipboard()324 AuraClipboard* GetClipboard() {
325 if (!aura_clipboard)
326 aura_clipboard = new AuraClipboard();
327 return aura_clipboard;
328 }
329
DeleteClipboard()330 void DeleteClipboard() {
331 if (aura_clipboard)
332 delete aura_clipboard;
333 aura_clipboard = NULL;
334 }
335
336 // Helper class to build a ClipboardData object and write it to clipboard.
337 class ClipboardDataBuilder {
338 public:
CommitToClipboard()339 static void CommitToClipboard() {
340 GetClipboard()->WriteData(GetCurrentData());
341 current_data_ = NULL;
342 }
343
WriteText(const char * text_data,size_t text_len)344 static void WriteText(const char* text_data, size_t text_len) {
345 ClipboardData* data = GetCurrentData();
346 data->set_text(std::string(text_data, text_len));
347 }
348
WriteHTML(const char * markup_data,size_t markup_len,const char * url_data,size_t url_len)349 static void WriteHTML(const char* markup_data,
350 size_t markup_len,
351 const char* url_data,
352 size_t url_len) {
353 ClipboardData* data = GetCurrentData();
354 data->set_markup_data(std::string(markup_data, markup_len));
355 data->set_url(std::string(url_data, url_len));
356 }
357
WriteRTF(const char * rtf_data,size_t rtf_len)358 static void WriteRTF(const char* rtf_data, size_t rtf_len) {
359 ClipboardData* data = GetCurrentData();
360 data->SetRTFData(std::string(rtf_data, rtf_len));
361 }
362
WriteBookmark(const char * title_data,size_t title_len,const char * url_data,size_t url_len)363 static void WriteBookmark(const char* title_data,
364 size_t title_len,
365 const char* url_data,
366 size_t url_len) {
367 ClipboardData* data = GetCurrentData();
368 data->set_bookmark_title(std::string(title_data, title_len));
369 data->set_bookmark_url(std::string(url_data, url_len));
370 }
371
WriteWebSmartPaste()372 static void WriteWebSmartPaste() {
373 ClipboardData* data = GetCurrentData();
374 data->set_web_smart_paste(true);
375 }
376
WriteBitmap(const SkBitmap & bitmap)377 static void WriteBitmap(const SkBitmap& bitmap) {
378 ClipboardData* data = GetCurrentData();
379 data->SetBitmapData(bitmap);
380 }
381
WriteData(const std::string & format,const char * data_data,size_t data_len)382 static void WriteData(const std::string& format,
383 const char* data_data,
384 size_t data_len) {
385 ClipboardData* data = GetCurrentData();
386 data->SetCustomData(format, std::string(data_data, data_len));
387 }
388
389 private:
GetCurrentData()390 static ClipboardData* GetCurrentData() {
391 if (!current_data_)
392 current_data_ = new ClipboardData;
393 return current_data_;
394 }
395
396 static ClipboardData* current_data_;
397 };
398
399 ClipboardData* ClipboardDataBuilder::current_data_ = NULL;
400
401 } // namespace
402
FormatType()403 Clipboard::FormatType::FormatType() {
404 }
405
FormatType(const std::string & native_format)406 Clipboard::FormatType::FormatType(const std::string& native_format)
407 : data_(native_format) {
408 }
409
~FormatType()410 Clipboard::FormatType::~FormatType() {
411 }
412
Serialize() const413 std::string Clipboard::FormatType::Serialize() const {
414 return data_;
415 }
416
417 // static
Deserialize(const std::string & serialization)418 Clipboard::FormatType Clipboard::FormatType::Deserialize(
419 const std::string& serialization) {
420 return FormatType(serialization);
421 }
422
operator <(const FormatType & other) const423 bool Clipboard::FormatType::operator<(const FormatType& other) const {
424 return data_ < other.data_;
425 }
426
Equals(const FormatType & other) const427 bool Clipboard::FormatType::Equals(const FormatType& other) const {
428 return data_ == other.data_;
429 }
430
Clipboard()431 Clipboard::Clipboard() {
432 DCHECK(CalledOnValidThread());
433 // Make sure clipboard is created.
434 GetClipboard();
435 }
436
~Clipboard()437 Clipboard::~Clipboard() {
438 DCHECK(CalledOnValidThread());
439 DeleteClipboard();
440 }
441
WriteObjects(ClipboardType type,const ObjectMap & objects)442 void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
443 DCHECK(CalledOnValidThread());
444 DCHECK(IsSupportedClipboardType(type));
445 for (ObjectMap::const_iterator iter = objects.begin();
446 iter != objects.end(); ++iter) {
447 DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
448 }
449 ClipboardDataBuilder::CommitToClipboard();
450 }
451
IsFormatAvailable(const FormatType & format,ClipboardType type) const452 bool Clipboard::IsFormatAvailable(const FormatType& format,
453 ClipboardType type) const {
454 DCHECK(CalledOnValidThread());
455 DCHECK(IsSupportedClipboardType(type));
456 AuraClipboard* clipboard = GetClipboard();
457 if (GetPlainTextFormatType().Equals(format) ||
458 GetUrlFormatType().Equals(format))
459 return clipboard->IsFormatAvailable(TEXT);
460 else if (GetHtmlFormatType().Equals(format))
461 return clipboard->IsFormatAvailable(HTML);
462 else if (GetRtfFormatType().Equals(format))
463 return clipboard->IsFormatAvailable(RTF);
464 else if (GetBitmapFormatType().Equals(format))
465 return clipboard->IsFormatAvailable(BITMAP);
466 else if (GetWebKitSmartPasteFormatType().Equals(format))
467 return clipboard->IsFormatAvailable(WEB);
468 else {
469 const ClipboardData* data = clipboard->GetData();
470 if (data && data->custom_data_format() == format.ToString())
471 return true;
472 }
473 return false;
474 }
475
Clear(ClipboardType type)476 void Clipboard::Clear(ClipboardType type) {
477 DCHECK(CalledOnValidThread());
478 DCHECK(IsSupportedClipboardType(type));
479 AuraClipboard* clipboard = GetClipboard();
480 clipboard->Clear();
481 }
482
ReadAvailableTypes(ClipboardType type,std::vector<string16> * types,bool * contains_filenames) const483 void Clipboard::ReadAvailableTypes(ClipboardType type,
484 std::vector<string16>* types,
485 bool* contains_filenames) const {
486 DCHECK(CalledOnValidThread());
487 if (!types || !contains_filenames) {
488 NOTREACHED();
489 return;
490 }
491
492 types->clear();
493 *contains_filenames = false;
494 if (IsFormatAvailable(GetPlainTextFormatType(), type))
495 types->push_back(UTF8ToUTF16(GetPlainTextFormatType().ToString()));
496 if (IsFormatAvailable(GetHtmlFormatType(), type))
497 types->push_back(UTF8ToUTF16(GetHtmlFormatType().ToString()));
498 if (IsFormatAvailable(GetRtfFormatType(), type))
499 types->push_back(UTF8ToUTF16(GetRtfFormatType().ToString()));
500 if (IsFormatAvailable(GetBitmapFormatType(), type))
501 types->push_back(UTF8ToUTF16(kMimeTypePNG));
502
503 AuraClipboard* clipboard = GetClipboard();
504 if (clipboard->IsFormatAvailable(CUSTOM) && clipboard->GetData()) {
505 ui::ReadCustomDataTypes(clipboard->GetData()->custom_data_data().c_str(),
506 clipboard->GetData()->custom_data_data().size(), types);
507 }
508 }
509
ReadText(ClipboardType type,string16 * result) const510 void Clipboard::ReadText(ClipboardType type, string16* result) const {
511 DCHECK(CalledOnValidThread());
512 GetClipboard()->ReadText(result);
513 }
514
ReadAsciiText(ClipboardType type,std::string * result) const515 void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
516 DCHECK(CalledOnValidThread());
517 GetClipboard()->ReadAsciiText(result);
518 }
519
ReadHTML(ClipboardType type,string16 * markup,std::string * src_url,uint32 * fragment_start,uint32 * fragment_end) const520 void Clipboard::ReadHTML(ClipboardType type,
521 string16* markup,
522 std::string* src_url,
523 uint32* fragment_start,
524 uint32* fragment_end) const {
525 DCHECK(CalledOnValidThread());
526 GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end);
527 }
528
ReadRTF(ClipboardType type,std::string * result) const529 void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
530 DCHECK(CalledOnValidThread());
531 GetClipboard()->ReadRTF(result);
532 }
533
ReadImage(ClipboardType type) const534 SkBitmap Clipboard::ReadImage(ClipboardType type) const {
535 DCHECK(CalledOnValidThread());
536 return GetClipboard()->ReadImage();
537 }
538
ReadCustomData(ClipboardType clipboard_type,const string16 & type,string16 * result) const539 void Clipboard::ReadCustomData(ClipboardType clipboard_type,
540 const string16& type,
541 string16* result) const {
542 DCHECK(CalledOnValidThread());
543 GetClipboard()->ReadCustomData(type, result);
544 }
545
ReadBookmark(string16 * title,std::string * url) const546 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
547 DCHECK(CalledOnValidThread());
548 GetClipboard()->ReadBookmark(title, url);
549 }
550
ReadData(const FormatType & format,std::string * result) const551 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
552 DCHECK(CalledOnValidThread());
553 GetClipboard()->ReadData(format.ToString(), result);
554 }
555
GetSequenceNumber(ClipboardType type)556 uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
557 DCHECK(CalledOnValidThread());
558 return GetClipboard()->GetNumClipboardEntries();
559 }
560
WriteText(const char * text_data,size_t text_len)561 void Clipboard::WriteText(const char* text_data, size_t text_len) {
562 ClipboardDataBuilder::WriteText(text_data, text_len);
563 }
564
WriteHTML(const char * markup_data,size_t markup_len,const char * url_data,size_t url_len)565 void Clipboard::WriteHTML(const char* markup_data,
566 size_t markup_len,
567 const char* url_data,
568 size_t url_len) {
569 ClipboardDataBuilder::WriteHTML(markup_data, markup_len, url_data, url_len);
570 }
571
WriteRTF(const char * rtf_data,size_t data_len)572 void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
573 ClipboardDataBuilder::WriteRTF(rtf_data, data_len);
574 }
575
WriteBookmark(const char * title_data,size_t title_len,const char * url_data,size_t url_len)576 void Clipboard::WriteBookmark(const char* title_data,
577 size_t title_len,
578 const char* url_data,
579 size_t url_len) {
580 ClipboardDataBuilder::WriteBookmark(title_data, title_len, url_data, url_len);
581 }
582
WriteWebSmartPaste()583 void Clipboard::WriteWebSmartPaste() {
584 ClipboardDataBuilder::WriteWebSmartPaste();
585 }
586
WriteBitmap(const SkBitmap & bitmap)587 void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
588 ClipboardDataBuilder::WriteBitmap(bitmap);
589 }
590
WriteData(const FormatType & format,const char * data_data,size_t data_len)591 void Clipboard::WriteData(const FormatType& format,
592 const char* data_data,
593 size_t data_len) {
594 ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len);
595 }
596
597 // static
GetFormatType(const std::string & format_string)598 Clipboard::FormatType Clipboard::GetFormatType(
599 const std::string& format_string) {
600 return FormatType::Deserialize(format_string);
601 }
602
603 // static
GetUrlFormatType()604 const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
605 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeURIList));
606 return type;
607 }
608
609 // static
GetUrlWFormatType()610 const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
611 return GetUrlFormatType();
612 }
613
614 // static
GetPlainTextFormatType()615 const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
616 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeText));
617 return type;
618 }
619
620 // static
GetPlainTextWFormatType()621 const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
622 return GetPlainTextFormatType();
623 }
624
625 // static
GetFilenameFormatType()626 const Clipboard::FormatType& Clipboard::GetFilenameFormatType() {
627 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeFilename));
628 return type;
629 }
630
631 // static
GetFilenameWFormatType()632 const Clipboard::FormatType& Clipboard::GetFilenameWFormatType() {
633 return Clipboard::GetFilenameFormatType();
634 }
635
636 // static
GetHtmlFormatType()637 const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
638 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeHTML));
639 return type;
640 }
641
642 // static
GetRtfFormatType()643 const Clipboard::FormatType& Clipboard::GetRtfFormatType() {
644 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeRTF));
645 return type;
646 }
647
648 // static
GetBitmapFormatType()649 const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
650 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeBitmap));
651 return type;
652 }
653
654 // static
GetWebKitSmartPasteFormatType()655 const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
656 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebkitSmartPaste));
657 return type;
658 }
659
660 // static
GetWebCustomDataFormatType()661 const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
662 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebCustomData));
663 return type;
664 }
665
666 // static
GetPepperCustomDataFormatType()667 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
668 CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
669 return type;
670 }
671
672 } // namespace ui
673