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

ui/base/clipboard/clipboard_aurax11.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 <list>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 398 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() {
+  DCHECK(CalledOnValidThread());
   // Make sure clipboard is created.
   GetClipboard();
 }
 
 Clipboard::~Clipboard() {
+  DCHECK(CalledOnValidThread());
   DeleteClipboard();
 }
 
 void Clipboard::WriteObjects(Buffer buffer, const ObjectMap& objects) {
+  DCHECK(CalledOnValidThread());
   DCHECK(IsValidBuffer(buffer));
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
   ClipboardDataBuilder::CommitToClipboard();
 }
 
 bool Clipboard::IsFormatAvailable(const FormatType& format,
                                   Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
   DCHECK(IsValidBuffer(buffer));
   AuraClipboard* clipboard = GetClipboard();
   if (GetPlainTextFormatType().Equals(format))
     return clipboard->IsFormatAvailable(TEXT);
   else if (GetHtmlFormatType().Equals(format))
     return clipboard->IsFormatAvailable(HTML);
   else if (GetBitmapFormatType().Equals(format))
     return clipboard->IsFormatAvailable(BITMAP);
   else if (GetWebKitSmartPasteFormatType().Equals(format))
     return clipboard->IsFormatAvailable(WEB);
   else {
     const ClipboardData* data = clipboard->GetData();
     if (data && data->custom_data_format() == format.ToString())
       return true;
   }
   return false;
 }
 
 void Clipboard::ReadAvailableTypes(Buffer buffer, std::vector<string16>* types,
     bool* contains_filenames) const {
+  DCHECK(CalledOnValidThread());
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
   types->clear();
   *contains_filenames = false;
   if (IsFormatAvailable(GetPlainTextFormatType(), buffer))
     types->push_back(UTF8ToUTF16(GetPlainTextFormatType().ToString()));
   if (IsFormatAvailable(GetHtmlFormatType(), buffer))
     types->push_back(UTF8ToUTF16(GetHtmlFormatType().ToString()));
   if (IsFormatAvailable(GetBitmapFormatType(), buffer))
     types->push_back(UTF8ToUTF16(GetBitmapFormatType().ToString()));
 
   AuraClipboard* clipboard = GetClipboard();
   if (clipboard->IsFormatAvailable(CUSTOM) && clipboard->GetData()) {
     ui::ReadCustomDataTypes(clipboard->GetData()->custom_data_data(),
         clipboard->GetData()->custom_data_len(), types);
   }
 }
 
 void Clipboard::ReadText(Buffer buffer, string16* result) const {
+  DCHECK(CalledOnValidThread());
   GetClipboard()->ReadText(result);
 }
 
 void Clipboard::ReadAsciiText(Buffer buffer, std::string* result) const {
+  DCHECK(CalledOnValidThread());
   GetClipboard()->ReadAsciiText(result);
 }
 
 void Clipboard::ReadHTML(Buffer buffer,
                          string16* markup,
                          std::string* src_url,
                          uint32* fragment_start,
                          uint32* fragment_end) const {
+  DCHECK(CalledOnValidThread());
   GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end);
 }
 
 SkBitmap Clipboard::ReadImage(Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
   return GetClipboard()->ReadImage();
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
+  DCHECK(CalledOnValidThread());
   GetClipboard()->ReadCustomData(type, result);
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+  DCHECK(CalledOnValidThread());
   GetClipboard()->ReadBookmark(title, url);
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
+  DCHECK(CalledOnValidThread());
   GetClipboard()->ReadData(format.ToString(), result);
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
+  DCHECK(CalledOnValidThread());
   return GetClipboard()->GetNumClipboardEntries();
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
   ClipboardDataBuilder::WriteText(text_data, text_len);
 }
 
 void Clipboard::WriteHTML(const char* markup_data,
                           size_t markup_len,
                           const char* url_data,
@@ skipping 68 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebCustomData));
   return type;
 }
 
 }  // namespace ui