Change all platforms except Windows to access the clipboard solely from the UI thread

ui/base/clipboard/clipboard_gtk.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <gtk/gtk.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <map>
@@ skipping 192 matching lines @@
 Clipboard::FormatType Clipboard::FormatType::Deserialize(
     const std::string& serialization) {
   return FormatType(serialization);
 }
 
 bool Clipboard::FormatType::Equals(const FormatType& other) const {
   return data_ == other.data_;
 }
 
 Clipboard::Clipboard() : clipboard_data_(NULL) {
+  DCHECK(CalledOnValidThread());
   clipboard_ = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
   primary_selection_ = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 }
 
 Clipboard::~Clipboard() {
+  DCHECK(CalledOnValidThread());
   gtk_clipboard_store(clipboard_);
 }
 
 void Clipboard::WriteObjects(Buffer buffer, const ObjectMap& objects) {
+  DCHECK(CalledOnValidThread());
   clipboard_data_ = new TargetMap();
 
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 
   SetGtkClipboard(buffer);
 }
 
 // When a URL is copied from a render view context menu (via "copy link
 // location", for example), we additionally stick it in the X clipboard. This
 // matches other linux browsers.
 void Clipboard::DidWriteURL(const std::string& utf8_text) {
+  DCHECK(CalledOnValidThread());
   gtk_clipboard_set_text(primary_selection_, utf8_text.c_str(),
                          utf8_text.length());
 }
 
 // Take ownership of the GTK clipboard and inform it of the targets we support.
 void Clipboard::SetGtkClipboard(Buffer buffer) {
   scoped_array<GtkTargetEntry> targets(
       new GtkTargetEntry[clipboard_data_->size()]);
 
   int i = 0;
@@ skipping 96 matching lines @@
   memcpy(data, data_data, data_len);
   // TODO(dcheng): Maybe this map should use GdkAtoms...
   InsertMapping(GdkAtomToString(format.ToGdkAtom()).c_str(), data, data_len);
 }
 
 // We do not use gtk_clipboard_wait_is_target_available because of
 // a bug with the gtk clipboard. It caches the available targets
 // and does not always refresh the cache when it is appropriate.
 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
                                   Clipboard::Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return false;
 
   bool retval = false;
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
       clipboard, gdk_atom_intern_static_string("TARGETS"));
 
   bool format_is_plain_text = GetPlainTextFormatType().Equals(format);
   if (format_is_plain_text) {
@@ skipping 29 matching lines @@
 
   if (data)
     gtk_selection_data_free(data);
 
   return retval;
 }
 
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
                                    std::vector<string16>* types,
                                    bool* contains_filenames) const {
+  DCHECK(CalledOnValidThread());
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
   types->clear();
   if (IsFormatAvailable(GetPlainTextFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (IsFormatAvailable(GetHtmlFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
@@ skipping 10 matching lines @@
   if (!data)
     return;
   ReadCustomDataTypes(gtk_selection_data_get_data(data),
                       gtk_selection_data_get_length(data),
                       types);
   gtk_selection_data_free(data);
 }
 
 
 void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
+  DCHECK(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return;
 
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard);
 
   if (text == NULL)
     return;
 
   // TODO(estade): do we want to handle the possible error here?
   UTF8ToUTF16(text, strlen(text), result);
   g_free(text);
 }
 
 void Clipboard::ReadAsciiText(Clipboard::Buffer buffer,
                               std::string* result) const {
+  DCHECK(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return;
 
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard);
 
   if (text == NULL)
     return;
 
   result->assign(text);
   g_free(text);
 }
 
 // TODO(estade): handle different charsets.
 // TODO(port): set *src_url.
 void Clipboard::ReadHTML(Clipboard::Buffer buffer, string16* markup,
                          std::string* src_url, uint32* fragment_start,
                          uint32* fragment_end) const {
+  DCHECK(CalledOnValidThread());
   markup->clear();
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return;
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard,
@@ skipping 20 matching lines @@
     markup->resize(markup->length() - 1);
 
   *fragment_start = 0;
   DCHECK(markup->length() <= kuint32max);
   *fragment_end = static_cast<uint32>(markup->length());
 
   gtk_selection_data_free(data);
 }
 
 SkBitmap Clipboard::ReadImage(Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
   ScopedGObject<GdkPixbuf>::Type pixbuf(
       gtk_clipboard_wait_for_image(clipboard_));
   if (!pixbuf.get())
     return SkBitmap();
 
   gfx::CanvasSkia canvas(gfx::Size(gdk_pixbuf_get_width(pixbuf.get()),
                                    gdk_pixbuf_get_height(pixbuf.get())),
                          false);
   {
     skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
     cairo_t* context = scoped_platform_paint.GetPlatformSurface();
     gdk_cairo_set_source_pixbuf(context, pixbuf.get(), 0.0, 0.0);
     cairo_paint(context);
   }
   return canvas.ExtractBitmap();
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
+  DCHECK(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (!clipboard)
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataForType(gtk_selection_data_get_data(data),
                         gtk_selection_data_get_length(data),
                         type, result);
   gtk_selection_data_free(data);
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   // TODO(estade): implement this.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
+  DCHECK(CalledOnValidThread());
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard_, format.ToGdkAtom());
   if (!data)
     return;
   result->assign(reinterpret_cast<const char*>(
                      gtk_selection_data_get_data(data)),
                  gtk_selection_data_get_length(data));
   gtk_selection_data_free(data);
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
+  DCHECK(CalledOnValidThread());
   if (buffer == BUFFER_STANDARD)
     return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
   else
     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
 //static
 Clipboard::FormatType Clipboard::GetFormatType(
     const std::string& format_string) {
   return FormatType::Deserialize(format_string);
@@ skipping 48 matching lines @@
       return clipboard_;
     case BUFFER_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace ui