src/ui/base/clipboard/clipboard_gtk.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 "ui/base/clipboard/clipboard.h"
   6
   7 #include <gtk/gtk.h>
   8 #include <X11/extensions/Xfixes.h>
   9 #include <X11/Xatom.h>
  10 #include <map>
  11 #include <set>
  12 #include <string>
  13 #include <utility>
  14
  15 #include "base/basictypes.h"
  16 #include "base/files/file_path.h"
  17 #include "base/logging.h"
  18 #include "base/memory/singleton.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "third_party/skia/include/core/SkBitmap.h"
  21 #include "ui/base/clipboard/custom_data_helper.h"
  22 #include "ui/base/gtk/gtk_signal.h"
  23 #include "ui/base/x/x11_util.h"
  24 #include "ui/gfx/canvas.h"
  25 #include "ui/gfx/gtk_util.h"
  26 #include "ui/gfx/scoped_gobject.h"
  27 #include "ui/gfx/size.h"
  28
  29 namespace ui {
  30
  31 namespace {
  32
  33 class SelectionChangeObserver {
  34  public:
  35   static SelectionChangeObserver* GetInstance();
  36
  37   uint64 clipboard_sequence_number() const {
  38     return clipboard_sequence_number_;
  39   }
  40   uint64 primary_sequence_number() const { return primary_sequence_number_; }
  41
  42  private:
  43   friend struct DefaultSingletonTraits<SelectionChangeObserver>;
  44
  45   SelectionChangeObserver();
  46   ~SelectionChangeObserver();
  47
  48   CHROMEG_CALLBACK_1(SelectionChangeObserver, GdkFilterReturn, OnXEvent,
  49                      GdkXEvent*, GdkEvent*);
  50
  51   int event_base_;
  52   Atom clipboard_atom_;
  53   uint64 clipboard_sequence_number_;
  54   uint64 primary_sequence_number_;
  55
  56   DISALLOW_COPY_AND_ASSIGN(SelectionChangeObserver);
  57 };
  58
  59 SelectionChangeObserver::SelectionChangeObserver()
  60     : event_base_(-1),
  61       clipboard_atom_(None),
  62       clipboard_sequence_number_(0),
  63       primary_sequence_number_(0) {
  64   int ignored;
  65   if (XFixesQueryExtension(gfx::GetXDisplay(), &event_base_, &ignored)) {
  66     clipboard_atom_ = XInternAtom(gfx::GetXDisplay(), "CLIPBOARD", false);
  67     XFixesSelectSelectionInput(gfx::GetXDisplay(), GetX11RootWindow(),
  68                                clipboard_atom_,
  69                                XFixesSetSelectionOwnerNotifyMask |
  70                                XFixesSelectionWindowDestroyNotifyMask |
  71                                XFixesSelectionClientCloseNotifyMask);
  72     // This seems to be semi-optional. For some reason, registering for any
  73     // selection notify events seems to subscribe us to events for both the
  74     // primary and the clipboard buffers. Register anyway just to be safe.
  75     XFixesSelectSelectionInput(gfx::GetXDisplay(), GetX11RootWindow(),
  76                                XA_PRIMARY,
  77                                XFixesSetSelectionOwnerNotifyMask |
  78                                XFixesSelectionWindowDestroyNotifyMask |
  79                                XFixesSelectionClientCloseNotifyMask);
  80     gdk_window_add_filter(NULL, &SelectionChangeObserver::OnXEventThunk, this);
  81   }
  82 }
  83
  84 SelectionChangeObserver::~SelectionChangeObserver() {
  85 }
  86
  87 SelectionChangeObserver* SelectionChangeObserver::GetInstance() {
  88   return Singleton<SelectionChangeObserver>::get();
  89 }
  90
  91 GdkFilterReturn SelectionChangeObserver::OnXEvent(GdkXEvent* xevent,
  92                                                   GdkEvent* event) {
  93   XEvent* xev = static_cast<XEvent*>(xevent);
  94
  95   if (xev->type == event_base_ + XFixesSelectionNotify) {
  96     XFixesSelectionNotifyEvent* ev =
  97         reinterpret_cast<XFixesSelectionNotifyEvent*>(xev);
  98     if (ev->selection == clipboard_atom_) {
  99       clipboard_sequence_number_++;
 100     } else if (ev->selection == XA_PRIMARY) {
 101       primary_sequence_number_++;
 102     } else {
 103       DLOG(ERROR) << "Unexpected selection atom: " << ev->selection;
 104     }
 105   }
 106   return GDK_FILTER_CONTINUE;
 107 }
 108
 109 const char kMimeTypeBitmap[] = "image/bmp";
 110 const char kMimeTypeMozillaURL[] = "text/x-moz-url";
 111 const char kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";
 112 const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
 113
 114 std::string GdkAtomToString(const GdkAtom& atom) {
 115   gchar* name = gdk_atom_name(atom);
 116   std::string rv(name);
 117   g_free(name);
 118   return rv;
 119 }
 120
 121 GdkAtom StringToGdkAtom(const std::string& str) {
 122   return gdk_atom_intern(str.c_str(), FALSE);
 123 }
 124
 125 // GtkClipboardGetFunc callback.
 126 // GTK will call this when an application wants data we copied to the clipboard.
 127 void GetData(GtkClipboard* clipboard,
 128              GtkSelectionData* selection_data,
 129              guint info,
 130              gpointer user_data) {
 131   Clipboard::TargetMap* data_map =
 132       reinterpret_cast<Clipboard::TargetMap*>(user_data);
 133
 134   std::string target_string = GdkAtomToString(
 135       gtk_selection_data_get_target(selection_data));
 136   Clipboard::TargetMap::iterator iter = data_map->find(target_string);
 137
 138   if (iter == data_map->end())
 139     return;
 140
 141   if (target_string == kMimeTypeBitmap) {
 142     gtk_selection_data_set_pixbuf(selection_data,
 143         reinterpret_cast<GdkPixbuf*>(iter->second.first));
 144   } else {
 145     gtk_selection_data_set(selection_data,
 146                            gtk_selection_data_get_target(selection_data), 8,
 147                            reinterpret_cast<guchar*>(iter->second.first),
 148                            iter->second.second);
 149   }
 150 }
 151
 152 // GtkClipboardClearFunc callback.
 153 // We are guaranteed this will be called exactly once for each call to
 154 // gtk_clipboard_set_with_data.
 155 void ClearData(GtkClipboard* /*clipboard*/,
 156                gpointer user_data) {
 157   Clipboard::TargetMap* map =
 158       reinterpret_cast<Clipboard::TargetMap*>(user_data);
 159   // The same data may be inserted under multiple keys, so use a set to
 160   // uniq them.
 161   std::set<char*> ptrs;
 162
 163   for (Clipboard::TargetMap::iterator iter = map->begin();
 164        iter != map->end(); ++iter) {
 165     if (iter->first == kMimeTypeBitmap)
 166       g_object_unref(reinterpret_cast<GdkPixbuf*>(iter->second.first));
 167     else
 168       ptrs.insert(iter->second.first);
 169   }
 170
 171   for (std::set<char*>::iterator iter = ptrs.begin();
 172        iter != ptrs.end(); ++iter) {
 173     delete[] *iter;
 174   }
 175
 176   delete map;
 177 }
 178
 179 }  // namespace
 180
 181 Clipboard::FormatType::FormatType() : data_(GDK_NONE) {
 182 }
 183
 184 Clipboard::FormatType::FormatType(const std::string& format_string)
 185     : data_(StringToGdkAtom(format_string)) {
 186 }
 187
 188 Clipboard::FormatType::FormatType(const GdkAtom& native_format)
 189     : data_(native_format) {
 190 }
 191
 192 Clipboard::FormatType::~FormatType() {
 193 }
 194
 195 std::string Clipboard::FormatType::Serialize() const {
 196   return GdkAtomToString(data_);
 197 }
 198
 199 // static
 200 Clipboard::FormatType Clipboard::FormatType::Deserialize(
 201     const std::string& serialization) {
 202   return FormatType(serialization);
 203 }
 204
 205 bool Clipboard::FormatType::Equals(const FormatType& other) const {
 206   return data_ == other.data_;
 207 }
 208
 209 Clipboard::Clipboard() : clipboard_data_(NULL) {
 210   DCHECK(CalledOnValidThread());
 211   clipboard_ = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 212   primary_selection_ = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 213 }
 214
 215 Clipboard::~Clipboard() {
 216   DCHECK(CalledOnValidThread());
 217   gtk_clipboard_store(clipboard_);
 218 }
 219
 220 void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
 221   DCHECK(CalledOnValidThread());
 222   clipboard_data_ = new TargetMap();
 223
 224   for (ObjectMap::const_iterator iter = objects.begin();
 225        iter != objects.end(); ++iter) {
 226     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
 227   }
 228   SetGtkClipboard(type);
 229
 230   if (type == CLIPBOARD_TYPE_COPY_PASTE) {
 231     ObjectMap::const_iterator text_iter = objects.find(CBF_TEXT);
 232     if (text_iter != objects.end()) {
 233       // Copy text and SourceTag to the selection clipboard.
 234       ObjectMap::const_iterator next_iter = text_iter;
 235       WriteObjects(CLIPBOARD_TYPE_SELECTION, ObjectMap(text_iter, ++next_iter));
 236     }
 237   }
 238 }
 239
 240 // Take ownership of the GTK clipboard and inform it of the targets we support.
 241 void Clipboard::SetGtkClipboard(ClipboardType type) {
 242   scoped_ptr<GtkTargetEntry[]> targets(
 243       new GtkTargetEntry[clipboard_data_->size()]);
 244
 245   int i = 0;
 246   for (Clipboard::TargetMap::iterator iter = clipboard_data_->begin();
 247        iter != clipboard_data_->end(); ++iter, ++i) {
 248     targets[i].target = const_cast<char*>(iter->first.c_str());
 249     targets[i].flags = 0;
 250     targets[i].info = 0;
 251   }
 252
 253   GtkClipboard *clipboard = LookupBackingClipboard(type);
 254
 255   if (gtk_clipboard_set_with_data(clipboard, targets.get(),
 256                                   clipboard_data_->size(),
 257                                   GetData, ClearData,
 258                                   clipboard_data_)) {
 259     gtk_clipboard_set_can_store(clipboard,
 260                                 targets.get(),
 261                                 clipboard_data_->size());
 262   }
 263
 264   // clipboard_data_ now owned by the GtkClipboard.
 265   clipboard_data_ = NULL;
 266 }
 267
 268 void Clipboard::WriteText(const char* text_data, size_t text_len) {
 269   char* data = new char[text_len];
 270   memcpy(data, text_data, text_len);
 271
 272   InsertMapping(kMimeTypeText, data, text_len);
 273   InsertMapping("TEXT", data, text_len);
 274   InsertMapping("STRING", data, text_len);
 275   InsertMapping("UTF8_STRING", data, text_len);
 276   InsertMapping("COMPOUND_TEXT", data, text_len);
 277 }
 278
 279 void Clipboard::WriteHTML(const char* markup_data,
 280                           size_t markup_len,
 281                           const char* url_data,
 282                           size_t url_len) {
 283   // TODO(estade): We need to expand relative links with |url_data|.
 284   static const char* html_prefix = "<meta http-equiv=\"content-type\" "
 285                                    "content=\"text/html; charset=utf-8\">";
 286   size_t html_prefix_len = strlen(html_prefix);
 287   size_t total_len = html_prefix_len + markup_len + 1;
 288
 289   char* data = new char[total_len];
 290   snprintf(data, total_len, "%s", html_prefix);
 291   memcpy(data + html_prefix_len, markup_data, markup_len);
 292   // Some programs expect NULL-terminated data. See http://crbug.com/42624
 293   data[total_len - 1] = '\0';
 294
 295   InsertMapping(kMimeTypeHTML, data, total_len);
 296 }
 297
 298 void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
 299   WriteData(GetRtfFormatType(), rtf_data, data_len);
 300 }
 301
 302 // Write an extra flavor that signifies WebKit was the last to modify the
 303 // pasteboard. This flavor has no data.
 304 void Clipboard::WriteWebSmartPaste() {
 305   InsertMapping(kMimeTypeWebkitSmartPaste, NULL, 0);
 306 }
 307
 308 void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
 309   const gfx::Size* size = reinterpret_cast<const gfx::Size*>(size_data);
 310
 311   // Adopt the pixels into a SkBitmap. Note that the pixel order in memory is
 312   // actually BGRA.
 313   SkBitmap bitmap;
 314   bitmap.setConfig(SkBitmap::kARGB_8888_Config, size->width(), size->height());
 315   bitmap.setPixels(const_cast<char*>(pixel_data));
 316   GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(bitmap);
 317
 318   // We store the GdkPixbuf*, and the size_t half of the pair is meaningless.
 319   // Note that this contrasts with the vast majority of entries in our target
 320   // map, which directly store the data and its length.
 321   InsertMapping(kMimeTypeBitmap, reinterpret_cast<char*>(pixbuf), 0);
 322 }
 323
 324 void Clipboard::WriteBookmark(const char* title_data, size_t title_len,
 325                               const char* url_data, size_t url_len) {
 326   // Write as a mozilla url (UTF16: URL, newline, title).
 327   string16 url = UTF8ToUTF16(std::string(url_data, url_len) + "\n");
 328   string16 title = UTF8ToUTF16(std::string(title_data, title_len));
 329   if (title.length() >= std::numeric_limits<size_t>::max() / 4 ||
 330       url.length() >= std::numeric_limits<size_t>::max() / 4)
 331     return;
 332   size_t data_len = 2 * (title.length() + url.length());
 333
 334   char* data = new char[data_len];
 335   memcpy(data, url.data(), 2 * url.length());
 336   memcpy(data + 2 * url.length(), title.data(), 2 * title.length());
 337   InsertMapping(kMimeTypeMozillaURL, data, data_len);
 338 }
 339
 340 void Clipboard::WriteData(const FormatType& format,
 341                           const char* data_data,
 342                           size_t data_len) {
 343   // We assume that certain mapping types are only written by trusted code.
 344   // Therefore we must upkeep their integrity.
 345   if (format.Equals(GetBitmapFormatType()))
 346     return;
 347   char* data = new char[data_len];
 348   memcpy(data, data_data, data_len);
 349   // TODO(dcheng): Maybe this map should use GdkAtoms...
 350   InsertMapping(GdkAtomToString(format.ToGdkAtom()).c_str(), data, data_len);
 351 }
 352
 353 // We do not use gtk_clipboard_wait_is_target_available because of
 354 // a bug with the gtk clipboard. It caches the available targets
 355 // and does not always refresh the cache when it is appropriate.
 356 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
 357                                   ClipboardType type) const {
 358   DCHECK(CalledOnValidThread());
 359   GtkClipboard* clipboard = LookupBackingClipboard(type);
 360   if (clipboard == NULL)
 361     return false;
 362
 363   bool retval = false;
 364   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
 365       clipboard, gdk_atom_intern_static_string("TARGETS"));
 366
 367   bool format_is_plain_text = GetPlainTextFormatType().Equals(format);
 368   if (format_is_plain_text) {
 369     // This tries a number of common text targets.
 370     if (data) {
 371       retval = gtk_selection_data_targets_include_text(data);
 372     }
 373     // Some programs like Java decide to set an empty TARGETS list, so even if
 374     // data is not NULL, we still have to fall back.
 375     if (!retval) {
 376       // Some programs post data to the clipboard without any targets. If this
 377       // is the case we attempt to make sense of the contents as text. This is
 378       // pretty unfortunate since it means we have to actually copy the data to
 379       // see if it is available, but at least this path shouldn't be hit for
 380       // conforming programs.
 381       gchar* text = gtk_clipboard_wait_for_text(clipboard);
 382       if (text) {
 383         g_free(text);
 384         retval = true;
 385       }
 386     }
 387   } else if (data) {
 388     GdkAtom* targets = NULL;
 389     int num = 0;
 390     gtk_selection_data_get_targets(data, &targets, &num);
 391
 392     for (int i = 0; i < num; i++) {
 393       if (targets[i] == format.ToGdkAtom()) {
 394         retval = true;
 395         break;
 396       }
 397     }
 398
 399     g_free(targets);
 400   }
 401
 402   if (data)
 403     gtk_selection_data_free(data);
 404
 405   return retval;
 406 }
 407
 408 void Clipboard::Clear(ClipboardType type) {
 409   DCHECK(CalledOnValidThread());
 410   GtkClipboard* clipboard = LookupBackingClipboard(type);
 411   if (clipboard == NULL)
 412     return;
 413   gtk_clipboard_clear(clipboard);
 414 }
 415
 416 void Clipboard::ReadAvailableTypes(ClipboardType type,
 417                                    std::vector<string16>* types,
 418                                    bool* contains_filenames) const {
 419   DCHECK(CalledOnValidThread());
 420   if (!types || !contains_filenames) {
 421     NOTREACHED();
 422     return;
 423   }
 424
 425   types->clear();
 426   if (IsFormatAvailable(GetPlainTextFormatType(), type))
 427     types->push_back(UTF8ToUTF16(kMimeTypeText));
 428   if (IsFormatAvailable(GetHtmlFormatType(), type))
 429     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
 430   if (IsFormatAvailable(GetRtfFormatType(), type))
 431     types->push_back(UTF8ToUTF16(kMimeTypeRTF));
 432   if (IsFormatAvailable(GetBitmapFormatType(), type))
 433     types->push_back(UTF8ToUTF16(kMimeTypePNG));
 434   *contains_filenames = false;
 435
 436   GtkClipboard* clipboard = LookupBackingClipboard(type);
 437   if (!clipboard)
 438     return;
 439
 440   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
 441       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
 442   if (!data)
 443     return;
 444   ReadCustomDataTypes(gtk_selection_data_get_data(data),
 445                       gtk_selection_data_get_length(data),
 446                       types);
 447   gtk_selection_data_free(data);
 448 }
 449
 450
 451 void Clipboard::ReadText(ClipboardType type, string16* result) const {
 452   DCHECK(CalledOnValidThread());
 453   GtkClipboard* clipboard = LookupBackingClipboard(type);
 454   if (clipboard == NULL)
 455     return;
 456
 457   result->clear();
 458   gchar* text = gtk_clipboard_wait_for_text(clipboard);
 459
 460   if (text == NULL)
 461     return;
 462
 463   // TODO(estade): do we want to handle the possible error here?
 464   UTF8ToUTF16(text, strlen(text), result);
 465   g_free(text);
 466 }
 467
 468 void Clipboard::ReadAsciiText(ClipboardType type,
 469                               std::string* result) const {
 470   DCHECK(CalledOnValidThread());
 471   GtkClipboard* clipboard = LookupBackingClipboard(type);
 472   if (clipboard == NULL)
 473     return;
 474
 475   result->clear();
 476   gchar* text = gtk_clipboard_wait_for_text(clipboard);
 477
 478   if (text == NULL)
 479     return;
 480
 481   result->assign(text);
 482   g_free(text);
 483 }
 484
 485 // TODO(estade): handle different charsets.
 486 // TODO(port): set *src_url.
 487 void Clipboard::ReadHTML(ClipboardType type,
 488                          string16* markup,
 489                          std::string* src_url,
 490                          uint32* fragment_start,
 491                          uint32* fragment_end) const {
 492   DCHECK(CalledOnValidThread());
 493   markup->clear();
 494   if (src_url)
 495     src_url->clear();
 496   *fragment_start = 0;
 497   *fragment_end = 0;
 498
 499   GtkClipboard* clipboard = LookupBackingClipboard(type);
 500   if (clipboard == NULL)
 501     return;
 502   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard,
 503       GetHtmlFormatType().ToGdkAtom());
 504
 505   if (!data)
 506     return;
 507
 508   // If the data starts with 0xFEFF, i.e., Byte Order Mark, assume it is
 509   // UTF-16, otherwise assume UTF-8.
 510   gint data_length = gtk_selection_data_get_length(data);
 511   const guchar* raw_data = gtk_selection_data_get_data(data);
 512
 513   if (data_length >= 2 &&
 514       reinterpret_cast<const uint16_t*>(raw_data)[0] == 0xFEFF) {
 515     markup->assign(reinterpret_cast<const uint16_t*>(raw_data) + 1,
 516                    (data_length / 2) - 1);
 517   } else {
 518     UTF8ToUTF16(reinterpret_cast<const char*>(raw_data), data_length, markup);
 519   }
 520
 521   // If there is a terminating NULL, drop it.
 522   if (!markup->empty() && markup->at(markup->length() - 1) == '\0')
 523     markup->resize(markup->length() - 1);
 524
 525   *fragment_start = 0;
 526   DCHECK(markup->length() <= kuint32max);
 527   *fragment_end = static_cast<uint32>(markup->length());
 528
 529   gtk_selection_data_free(data);
 530 }
 531
 532 void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
 533   DCHECK(CalledOnValidThread());
 534   ReadData(GetRtfFormatType(), result);
 535 }
 536
 537 SkBitmap Clipboard::ReadImage(ClipboardType type) const {
 538   DCHECK(CalledOnValidThread());
 539   ScopedGObject<GdkPixbuf>::Type pixbuf(
 540       gtk_clipboard_wait_for_image(clipboard_));
 541   if (!pixbuf.get())
 542     return SkBitmap();
 543
 544   gfx::Canvas canvas(gfx::Size(gdk_pixbuf_get_width(pixbuf.get()),
 545                                gdk_pixbuf_get_height(pixbuf.get())),
 546                      1.0f, false);
 547   {
 548     skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
 549     cairo_t* context = scoped_platform_paint.GetPlatformSurface();
 550     gdk_cairo_set_source_pixbuf(context, pixbuf.get(), 0.0, 0.0);
 551     cairo_paint(context);
 552   }
 553   return canvas.ExtractImageRep().sk_bitmap();
 554 }
 555
 556 void Clipboard::ReadCustomData(ClipboardType clipboard_type,
 557                                const string16& type,
 558                                string16* result) const {
 559   DCHECK(CalledOnValidThread());
 560   GtkClipboard* clipboard = LookupBackingClipboard(clipboard_type);
 561   if (!clipboard)
 562     return;
 563
 564   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
 565       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
 566   if (!data)
 567     return;
 568   ReadCustomDataForType(gtk_selection_data_get_data(data),
 569                         gtk_selection_data_get_length(data),
 570                         type, result);
 571   gtk_selection_data_free(data);
 572 }
 573
 574 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
 575   // TODO(estade): implement this.
 576   NOTIMPLEMENTED();
 577 }
 578
 579 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
 580   DCHECK(CalledOnValidThread());
 581   result->clear();
 582   GtkSelectionData* data =
 583       gtk_clipboard_wait_for_contents(clipboard_, format.ToGdkAtom());
 584   if (!data)
 585     return;
 586   result->assign(reinterpret_cast<const char*>(
 587                      gtk_selection_data_get_data(data)),
 588                  gtk_selection_data_get_length(data));
 589   gtk_selection_data_free(data);
 590 }
 591
 592 uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
 593   DCHECK(CalledOnValidThread());
 594   if (type == CLIPBOARD_TYPE_COPY_PASTE)
 595     return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
 596   else
 597     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 598 }
 599
 600 //static
 601 Clipboard::FormatType Clipboard::GetFormatType(
 602     const std::string& format_string) {
 603   return FormatType::Deserialize(format_string);
 604 }
 605
 606 // static
 607 const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
 608   CR_DEFINE_STATIC_LOCAL(
 609       FormatType, type, (GDK_TARGET_STRING));
 610   return type;
 611 }
 612
 613 // static
 614 const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
 615   return GetPlainTextFormatType();
 616 }
 617
 618 // static
 619 const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
 620   return GetPlainTextFormatType();
 621 }
 622
 623 // static
 624 const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
 625   return GetPlainTextWFormatType();
 626 }
 627
 628 // static
 629 const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
 630   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeHTML));
 631   return type;
 632 }
 633
 634 // static
 635 const Clipboard::FormatType& Clipboard::GetRtfFormatType() {
 636   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeRTF));
 637   return type;
 638 }
 639
 640 // static
 641 const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
 642   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeBitmap));
 643   return type;
 644 }
 645
 646 // static
 647 const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
 648   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebkitSmartPaste));
 649   return type;
 650 }
 651
 652 // static
 653 const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
 654   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebCustomData));
 655   return type;
 656 }
 657
 658 // static
 659 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
 660   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
 661   return type;
 662 }
 663
 664 void Clipboard::InsertMapping(const char* key,
 665                               char* data,
 666                               size_t data_len) {
 667   DCHECK(clipboard_data_->find(key) == clipboard_data_->end());
 668   (*clipboard_data_)[key] = std::make_pair(data, data_len);
 669 }
 670
 671 GtkClipboard* Clipboard::LookupBackingClipboard(ClipboardType type) const {
 672   switch (type) {
 673     case CLIPBOARD_TYPE_COPY_PASTE:
 674       return clipboard_;
 675     case CLIPBOARD_TYPE_SELECTION:
 676       return primary_selection_;
 677     default:
 678       NOTREACHED();
 679       return NULL;
 680   }
 681 }
 682
 683 }  // namespace ui