Make Clipboard::FormatType an opaque handle type.

ui/base/clipboard/clipboard_mac.mm

 // Copyright (c) 2011 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"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_nsobject.h"
+#include "base/stl_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #import "third_party/mozilla/NSPasteboard+Utils.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
@@ skipping 14 matching lines @@
   // The pasteboard should not be nil in a UI session, but this handy DCHECK
   // can help track down problems if someone tries using clipboard code outside
   // of a UI session.
   NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
   DCHECK(pasteboard);
   return pasteboard;
 }
 
 }  // namespace
 
+Clipboard::FormatType::FormatType() {
+}
+
+Clipboard::FormatType::FormatType(NSString* native_format)
+    : data_([native_format retain]) {
+}
+
+Clipboard::FormatType::FormatType(const FormatType& other)
+    : data_([other.data_ retain]) {
+}
+
+Clipboard::FormatType& Clipboard::FormatType::operator=(
+    const FormatType& other) {

[tony, 2011/12/06 23:57:20]

Why does mac need this?

[dcheng, 2011/12/07 00:09:02]

It's there for other platforms as well, it's just using the implicit ones. It's
so FormatType can be a drop-in replacement for std::string.

+  if (this != &other) {
+    [data_ release];
+    data_ = [other.data_ retain];
+  }
+  return *this;
+}
+
+Clipboard::FormatType::~FormatType() {
+  [data_ release];
+}
+
+std::string Clipboard::FormatType::Serialize() const {
+  return base::SysNSStringToUTF8(data_);
+}
+
+// static
+Clipboard::FormatType Clipboard::FormatType::Deserialize(
+    const std::string& serialization) {
+  return FormatType(base::SysUTF8ToNSString(serialization));
+}

[tony, 2011/12/06 23:57:21]

Where's Equals?  Maybe we don't need it?  Wouldn't hurt to define it even if we
don't use it.

[dcheng, 2011/12/07 00:09:02]

I intentionally left it out since there's no one that uses it on Mac/Win. It'd
be easy to add it if it ever changed in the future.

+
 Clipboard::Clipboard() {
 }
 
 Clipboard::~Clipboard() {
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   NSPasteboard* pb = GetPasteboard();
   [pb declareTypes:[NSArray array] owner:nil];
 
@@ skipping 92 matching lines @@
   // For now, spit out the image as a TIFF.
   NSPasteboard* pb = GetPasteboard();
   [pb addTypes:[NSArray arrayWithObject:NSTIFFPboardType] owner:nil];
   NSData *tiff_data = [image TIFFRepresentation];
   LOG_IF(ERROR, tiff_data == NULL) << "Failed to allocate image for clipboard";
   if (tiff_data) {
     [pb setData:tiff_data forType:NSTIFFPboardType];
   }
 }
 
-void Clipboard::WriteData(const char* format_name, size_t format_len,
-                          const char* data_data, size_t data_len) {
+void Clipboard::WriteData(const FormatType& format,
+                          const char* data_data,
+                          size_t data_len) {
   NSPasteboard* pb = GetPasteboard();
-  scoped_nsobject<NSString> format(
-      [[NSString alloc] initWithBytes:format_name
-                               length:format_len
-                             encoding:NSUTF8StringEncoding]);
-  [pb addTypes:[NSArray arrayWithObject:format] owner:nil];
+  [pb addTypes:[NSArray arrayWithObject:format.ToNSString()] owner:nil];
   [pb setData:[NSData dataWithBytes:data_data length:data_len]
-      forType:format];
+      forType:format.ToNSString()];
 }
 
 // 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 = base::SysUTF8ToNSString(GetWebKitSmartPasteFormatType());
+  NSString* format = GetWebKitSmartPasteFormatType().ToNSString();
   [pb addTypes:[NSArray arrayWithObject:format] owner:nil];
   [pb setData:nil forType:format];
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
 
   NSPasteboard* pb = GetPasteboard();
   return [pb changeCount];
 }
 
-bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
+bool Clipboard::IsFormatAvailable(const FormatType& format,
                                   Buffer buffer) const {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
-  NSString* format_ns = base::SysUTF8ToNSString(format);
 
   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_ns isEqualToString:NSHTMLPboardType]) {
+  if ([format.ToNSString() isEqualToString:NSHTMLPboardType]) {
     return [types containsObject:NSHTMLPboardType] ||
            [types containsObject:NSRTFPboardType];
   }
-  return [types containsObject:format_ns];
-}
-
-bool Clipboard::IsFormatAvailableByString(const std::string& format,
-                                          Buffer buffer) const {
-  DCHECK_EQ(buffer, BUFFER_STANDARD);
-  NSString* format_ns = base::SysUTF8ToNSString(format);
-
-  NSPasteboard* pb = GetPasteboard();
-  NSArray* types = [pb types];
-
-  return [types containsObject:format_ns];
+  return [types containsObject:format.ToNSString()];
 }
 
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
                                    std::vector<string16>* types,
                                    bool* contains_filenames) const {
-  if (!types || !contains_filenames) {
-    NOTREACHED();
-    return;
-  }
-
   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();
@@ skipping 141 matching lines @@
 
   NSPasteboard* pb = GetPasteboard();
   NSArray* fileList = [pb propertyListForType:NSFilenamesPboardType];
 
   for (unsigned int i = 0; i < [fileList count]; ++i) {
     std::string file = [[fileList objectAtIndex:i] UTF8String];
     files->push_back(FilePath(file));
   }
 }
 
-void Clipboard::ReadData(const std::string& format, std::string* result) const {
+void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   NSPasteboard* pb = GetPasteboard();
-  NSData* data = [pb dataForType:base::SysUTF8ToNSString(format)];
+  NSData* data = [pb dataForType:format.ToNSString()];
   if ([data length])
     result->assign(static_cast<const char*>([data bytes]), [data length]);
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlFormatType() {
-  return base::SysNSStringToUTF8(NSURLPboardType);
+Clipboard::FormatType Clipboard::GetFormatType(
+    const std::string& format_string) {
+  return FormatType::Deserialize(format_string);
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlWFormatType() {
-  return base::SysNSStringToUTF8(NSURLPboardType);
+const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSURLPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return base::SysNSStringToUTF8(NSStringPboardType);
+const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
+  return GetUrlFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
-  return base::SysNSStringToUTF8(NSStringPboardType);
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSStringPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameFormatType() {
-  return base::SysNSStringToUTF8(NSFilenamesPboardType);
+const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
+  return GetPlainTextFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameWFormatType() {
-  return base::SysNSStringToUTF8(NSFilenamesPboardType);
+const Clipboard::FormatType& Clipboard::GetFilenameFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSFilenamesPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetHtmlFormatType() {
-  return base::SysNSStringToUTF8(NSHTMLPboardType);
+const Clipboard::FormatType& Clipboard::GetFilenameWFormatType() {
+  return GetFilenameFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetBitmapFormatType() {
-  return base::SysNSStringToUTF8(NSTIFFPboardType);
+const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSHTMLPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
-  return base::SysNSStringToUTF8(kWebSmartPastePboardType);
+const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSTIFFPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebCustomDataFormatType() {
-  return base::SysNSStringToUTF8(kWebCustomDataType);
+const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kWebSmartPastePboardType));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kWebCustomDataType));
+  return type;
 }
 
 }  // namespace ui