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

ui/base/clipboard/clipboard_mac.mm

 // 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"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 61 matching lines @@
   return base::SysNSStringToUTF8(data_);
 }
 
 // static
 Clipboard::FormatType Clipboard::FormatType::Deserialize(
     const std::string& serialization) {
   return FormatType(base::SysUTF8ToNSString(serialization));
 }
 
 Clipboard::Clipboard() {
+  DCHECK(CalledOnValidThread());
 }
 
 Clipboard::~Clipboard() {
+  DCHECK(CalledOnValidThread());
 }
 
 void Clipboard::WriteObjects(Buffer buffer, const ObjectMap& objects) {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   NSPasteboard* pb = GetPasteboard();
   [pb declareTypes:[NSArray array] owner:nil];
 
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 }
@@ skipping 106 matching lines @@
 // Write an extra flavor that signifies WebKit was the last to modify the
 // pasteboard. This flavor has no data.
 void Clipboard::WriteWebSmartPaste() {
   NSPasteboard* pb = GetPasteboard();
   NSString* format = GetWebKitSmartPasteFormatType().ToNSString();
   [pb addTypes:[NSArray arrayWithObject:format] owner:nil];
   [pb setData:nil forType:format];
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   NSPasteboard* pb = GetPasteboard();
   return [pb changeCount];
 }
 
 bool Clipboard::IsFormatAvailable(const FormatType& format,
                                   Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   NSPasteboard* pb = GetPasteboard();
   NSArray* types = [pb types];
 
   // Safari only places RTF on the pasteboard, never HTML. We can convert RTF
   // to HTML, so the presence of either indicates success when looking for HTML.
   if ([format.ToNSString() isEqualToString:NSHTMLPboardType]) {
     return [types containsObject:NSHTMLPboardType] ||
            [types containsObject:NSRTFPboardType];
   }
   return [types containsObject:format.ToNSString()];
 }
 
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
                                    std::vector<string16>* types,
                                    bool* contains_filenames) const {
+  DCHECK(CalledOnValidThread());
   types->clear();
   if (IsFormatAvailable(Clipboard::GetPlainTextFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (IsFormatAvailable(Clipboard::GetHtmlFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
   if ([NSImage canInitWithPasteboard:GetPasteboard()])
     types->push_back(UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
 
   NSPasteboard* pb = GetPasteboard();
   if ([[pb types] containsObject:kWebCustomDataPboardType]) {
     NSData* data = [pb dataForType:kWebCustomDataPboardType];
     if ([data length])
       ReadCustomDataTypes([data bytes], [data length], types);
   }
 }
 
 void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
   NSPasteboard* pb = GetPasteboard();
   NSString* contents = [pb stringForType:NSStringPboardType];
 
   UTF8ToUTF16([contents UTF8String],
               [contents lengthOfBytesUsingEncoding:NSUTF8StringEncoding],
               result);
 }
 
 void Clipboard::ReadAsciiText(Clipboard::Buffer buffer,
                               std::string* result) const {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
   NSPasteboard* pb = GetPasteboard();
   NSString* contents = [pb stringForType:NSStringPboardType];
 
   if (!contents)
     result->clear();
   else
     result->assign([contents UTF8String]);
 }
 
 void Clipboard::ReadHTML(Clipboard::Buffer buffer, string16* markup,
                          std::string* src_url, uint32* fragment_start,
                          uint32* fragment_end) const {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   // TODO(avi): src_url?
   markup->clear();
   if (src_url)
     src_url->clear();
 
   NSPasteboard* pb = GetPasteboard();
   NSArray* supportedTypes = [NSArray arrayWithObjects:NSHTMLPboardType,
                                                       NSRTFPboardType,
                                                       NSStringPboardType,
                                                       nil];
   NSString* bestType = [pb availableTypeFromArray:supportedTypes];
   if (bestType) {
     NSString* contents = [pb stringForType:bestType];
     if ([bestType isEqualToString:NSRTFPboardType])
       contents = [pb htmlFromRtf];
     UTF8ToUTF16([contents UTF8String],
                 [contents lengthOfBytesUsingEncoding:NSUTF8StringEncoding],
                 markup);
   }
 
   *fragment_start = 0;
   DCHECK(markup->length() <= kuint32max);
   *fragment_end = static_cast<uint32>(markup->length());
 }
 
 SkBitmap Clipboard::ReadImage(Buffer buffer) const {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   scoped_nsobject<NSImage> image(
       [[NSImage alloc] initWithPasteboard:GetPasteboard()]);
   if (!image.get())
     return SkBitmap();
 
   gfx::ScopedNSGraphicsContextSaveGState scoped_state;
   [image setFlipped:YES];
   int width = [image size].width;
@@ skipping 10 matching lines @@
              fromRect:NSZeroRect
             operation:NSCompositeCopy
              fraction:1.0];
   }
   return canvas.ExtractBitmap();
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
+  DCHECK(CalledOnValidThread());
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   NSPasteboard* pb = GetPasteboard();
   if ([[pb types] containsObject:kWebCustomDataPboardType]) {
     NSData* data = [pb dataForType:kWebCustomDataPboardType];
     if ([data length])
       ReadCustomDataForType([data bytes], [data length], type, result);
   }
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+  DCHECK(CalledOnValidThread());
   NSPasteboard* pb = GetPasteboard();
 
   if (title) {
     NSString* contents = [pb stringForType:kUTTypeURLName];
     UTF8ToUTF16([contents UTF8String],
                 [contents lengthOfBytesUsingEncoding:NSUTF8StringEncoding],
                 title);
   }
 
   if (url) {
     NSString* url_string = [[NSURL URLFromPasteboard:pb] absoluteString];
     if (!url_string)
       url->clear();
     else
       url->assign([url_string UTF8String]);
   }
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
+  DCHECK(CalledOnValidThread());
   NSPasteboard* pb = GetPasteboard();
   NSData* data = [pb dataForType:format.ToNSString()];
   if ([data length])
     result->assign(static_cast<const char*>([data bytes]), [data length]);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetFormatType(
     const std::string& format_string) {
   return FormatType::Deserialize(format_string);
@@ skipping 50 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kWebCustomDataPboardType));
   return type;
 }
 
 }  // namespace ui