Make Clipboard::FormatType an opaque handle type.

ui/base/clipboard/clipboard_win.cc

 // 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.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <shlobj.h>
 #include <shellapi.h>
 
+#include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
-#include "base/string_number_conversions.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/wrapped_window_proc.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/clipboard_util_win.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/size.h"
@@ skipping 122 matching lines @@
 void MakeBitmapOpaque(const SkBitmap& bitmap) {
   for (int x = 0; x < bitmap.width(); ++x) {
     for (int y = 0; y < bitmap.height(); ++y) {
       *bitmap.getAddr32(x, y) = SkColorSetA(*bitmap.getAddr32(x, y), 0xFF);
     }
   }
 }
 
 }  // namespace
 
+Clipboard::FormatType::FormatType() {
+}
+
+Clipboard::FormatType::FormatType(UINT native_format) : data_(native_format) {
+}
+
+Clipboard::FormatType::~FormatType() {
+}
+
 Clipboard::Clipboard() : create_window_(false) {
   if (MessageLoop::current()->type() == MessageLoop::TYPE_UI) {
     // Make a dummy HWND to be the clipboard's owner.
     WNDCLASSEX wcex = {0};
     wcex.cbSize = sizeof(WNDCLASSEX);
     wcex.lpfnWndProc = base::win::WrappedWindowProc<ClipboardOwnerWndProc>;
     wcex.hInstance = GetModuleHandle(NULL);
     wcex.lpszClassName = L"ClipboardOwnerWindowClass";
     ::RegisterClassEx(&wcex);
     create_window_ = true;
@@ skipping 135 matching lines @@
   ::SelectObject(source_dc, old_source);
   ::DeleteObject(old_hbitmap);
   ::DeleteObject(old_source);
   ::DeleteDC(compatible_dc);
   ::DeleteDC(source_dc);
   ::ReleaseDC(NULL, dc);
 
   WriteToClipboard(CF_BITMAP, hbitmap);
 }
 
-void Clipboard::WriteData(const char* format_name, size_t format_len,
-                          const char* data_data, size_t data_len) {
-  std::string format(format_name, format_len);
-  CLIPFORMAT clip_format =
-      ::RegisterClipboardFormat(ASCIIToWide(format).c_str());
-
+void Clipboard::WriteData(const FormatType& format,
+                          const char* data_data,
+                          size_t data_len) {
   HGLOBAL hdata = ::GlobalAlloc(GMEM_MOVEABLE, data_len);
   if (!hdata)
     return;
 
   char* data = static_cast<char*>(::GlobalLock(hdata));
   memcpy(data, data_data, data_len);
   ::GlobalUnlock(data);
-  WriteToClipboard(clip_format, hdata);
+  WriteToClipboard(format.data(), hdata);
 }
 
 void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) {
   DCHECK(clipboard_owner_);
   if (handle && !::SetClipboardData(format, handle)) {
     DCHECK(ERROR_CLIPBOARD_NOT_OPEN != GetLastError());
     FreeData(format, handle);
   }
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
   return ::GetClipboardSequenceNumber();
 }
 
 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
                                   Clipboard::Buffer buffer) const {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
-  int f;
-  if (!base::StringToInt(format, &f))
-    return false;
-  return ::IsClipboardFormatAvailable(f) != FALSE;
-}
-
-bool Clipboard::IsFormatAvailableByString(
-    const std::string& ascii_format, Clipboard::Buffer buffer) const {
-  DCHECK_EQ(buffer, BUFFER_STANDARD);
-  std::wstring wide_format = ASCIIToWide(ascii_format);
-  CLIPFORMAT format = ::RegisterClipboardFormat(wide_format.c_str());
-  return ::IsClipboardFormatAvailable(format) != FALSE;
+  return ::IsClipboardFormatAvailable(format.data()) != FALSE;
 }
 
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
                                    std::vector<string16>* types,
                                    bool* contains_filenames) const {
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
@@ skipping 268 matching lines @@
     for (int i = 0; i < count; ++i) {
       UINT size = ::DragQueryFile(drop, i, NULL, 0) + 1;
       DCHECK_GT(size, 1u);
       std::wstring file;
       ::DragQueryFile(drop, i, WriteInto(&file, size), size);
       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 {
   if (!result) {
     NOTREACHED();
     return;
   }
 
-  CLIPFORMAT clip_format =
-      ::RegisterClipboardFormat(ASCIIToWide(format).c_str());
-
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE data = ::GetClipboardData(clip_format);
+  HANDLE data = ::GetClipboardData(format.data());
   if (!data)
     return;
 
   result->assign(static_cast<const char*>(::GlobalLock(data)),
                  ::GlobalSize(data));
   ::GlobalUnlock(data);
 }
 
 // static
 void Clipboard::ParseBookmarkClipboardFormat(const string16& bookmark,
                                              string16* title,
                                              std::string* url) {
   const string16 kDelim = ASCIIToUTF16("\r\n");
 
   const size_t title_end = bookmark.find_first_of(kDelim);
   if (title)
     title->assign(bookmark.substr(0, title_end));
 
   if (url) {
     const size_t url_start = bookmark.find_first_not_of(kDelim, title_end);
     if (url_start != string16::npos)
       *url = UTF16ToUTF8(bookmark.substr(url_start, string16::npos));
   }
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlFormatType() {
-  return base::IntToString(ClipboardUtil::GetUrlFormat()->cfFormat);
+Clipboard::FormatType Clipboard::RegisterFormatType(
+    const std::string& format_string) {
+  return FormatType(
+      ::RegisterClipboardFormat(ASCIIToWide(format_string).c_str()));

[tony, 2011/12/06 18:58:29]

Do we need to check the return value of RegisterClipboardFormat?

[dcheng, 2011/12/06 22:57:02]

We didn't check it before. If it fails, the other clipboard reading functions
will return failure.

 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlWFormatType() {
-  return base::IntToString(ClipboardUtil::GetUrlWFormat()->cfFormat);
+std::string Clipboard::FormatTypeToString(const FormatType& type) {
+  std::string result(sizeof(UINT), '\0');
+  *reinterpret_cast<UINT*>(string_as_array(&result)) = type.data();

[tony, 2011/12/06 18:58:29]

This seems unnecessarily clever/hard to read.  Can we just use StringPrintf and
UintToString for serializing/deserializing?

Alternately, you could typedef the serialization format and just use UINT on
Windows.

[dcheng, 2011/12/06 22:57:02]

Done. I was afraid someone would say that =)

It seems kind of dumb to itoa something only to atoi it back later.
Unfortunately, there's no real alternative at the moment because of the way
Clipboard::DispatchObjects() is implemented.

+  return result;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetMozUrlFormatType() {
-  return base::IntToString(ClipboardUtil::GetMozUrlFormat()->cfFormat);
+Clipboard::FormatType Clipboard::StringToFormatType(
+    const std::string& format_string) {
+  return FormatType(*reinterpret_cast<const UINT*>(format_string.data()));
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return base::IntToString(ClipboardUtil::GetPlainTextFormat()->cfFormat);
+// TODO(dcheng): Just substitue the appropriate constants here.
+const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetUrlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
-  return base::IntToString(ClipboardUtil::GetPlainTextWFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetUrlWFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameFormatType() {
-  return base::IntToString(ClipboardUtil::GetFilenameFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetMozUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetMozUrlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameWFormatType() {
-  return base::IntToString(ClipboardUtil::GetFilenameWFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetPlainTextFormat()->cfFormat));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetPlainTextWFormat()->cfFormat));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetFilenameFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFilenameFormat()->cfFormat));
+  return type;
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetFilenameWFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFilenameWFormat()->cfFormat));
+  return type;
 }
 
 // MS HTML Format
 // static
-Clipboard::FormatType Clipboard::GetHtmlFormatType() {
-  return base::IntToString(ClipboardUtil::GetHtmlFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetHtmlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetBitmapFormatType() {
-  return base::IntToString(CF_BITMAP);
+const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (CF_BITMAP));
+  return type;
 }
 
 // Firefox text/html
 // static
-Clipboard::FormatType Clipboard::GetTextHtmlFormatType() {
-  return base::IntToString(ClipboardUtil::GetTextHtmlFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetTextHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetTextHtmlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetCFHDropFormatType() {
-  return base::IntToString(ClipboardUtil::GetCFHDropFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetCFHDropFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetCFHDropFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFileDescriptorFormatType() {
-  return base::IntToString(ClipboardUtil::GetFileDescriptorFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetFileDescriptorFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFileDescriptorFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFileContentFormatZeroType() {
-  return base::IntToString(ClipboardUtil::GetFileContentFormatZero()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetFileContentFormatZeroType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFileContentFormatZero()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
-  return base::IntToString(
-      ClipboardUtil::GetWebKitSmartPasteFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetWebKitSmartPasteFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebCustomDataFormatType() {
-  // TODO(dcheng): Clean up the duplicated constant.
-  // Clipboard::WritePickledData() takes a FormatType, but all the callers
-  // assume that it's a raw string. As a result, we return the format name here
-  // rather than returning a string-ified version of the registered clipboard
-  // format ID.
-  return "Chromium Web Custom MIME Data Format";
+const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetWebCustomDataFormat()->cfFormat));
+  return type;
 }
 
 // static
 void Clipboard::FreeData(unsigned int format, HANDLE data) {
   if (format == CF_BITMAP)
     ::DeleteObject(static_cast<HBITMAP>(data));
   else
     ::GlobalFree(data);
 }
 
 HWND Clipboard::GetClipboardWindow() const {
   if (!clipboard_owner_ && create_window_) {
     clipboard_owner_ = ::CreateWindow(L"ClipboardOwnerWindowClass",
                                       L"ClipboardOwnerWindow",
                                       0, 0, 0, 0, 0,
                                       HWND_MESSAGE,
                                       0, 0, 0);
   }
   return clipboard_owner_;
 }
 
 }  // namespace ui