Change Clipboard to use virtual methods for testing purposes.

ui/base/clipboard/clipboard_win.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.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
-#include "ui/base/clipboard/clipboard.h"
+#include "ui/base/clipboard/clipboard_win.h"
 
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 133 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);
     }
   }
 }
 
+void ParseBookmarkClipboardFormat(const base::string16& bookmark,
+                                  base::string16* title,
+                                  std::string* url) {
+  const base::string16 kDelim = base::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 != base::string16::npos) {
+      *url =
+          base::UTF16ToUTF8(bookmark.substr(url_start, base::string16::npos));
+    }
+  }
+}
+
+void FreeData(unsigned int format, HANDLE data) {
+  if (format == CF_BITMAP)
+    ::DeleteObject(static_cast<HBITMAP>(data));
+  else
+    ::GlobalFree(data);
+}
+
 }  // namespace
 
 // Clipboard::FormatType implementation.
 Clipboard::FormatType::FormatType() : data_() {}
 
 Clipboard::FormatType::FormatType(UINT native_format) : data_() {
   // There's no good way to actually initialize this in the constructor in
   // C++03.
   data_.cfFormat = native_format;
   data_.dwAspect = DVASPECT_CONTENT;
@@ skipping 22 matching lines @@
     const std::string& serialization) {
   int clipboard_format = -1;
   if (!base::StringToInt(serialization, &clipboard_format)) {
     NOTREACHED();
     return FormatType();
   }
   return FormatType(clipboard_format);
 }
 
 bool Clipboard::FormatType::operator<(const FormatType& other) const {
-  return ToUINT() < other.ToUINT();
+  return data_.cfFormat < other.data_.cfFormat;
 }
 
 bool Clipboard::FormatType::Equals(const FormatType& other) const {
-  return ToUINT() == other.ToUINT();
+  return data_.cfFormat == other.data_.cfFormat;
 }
 
 // Various predefined FormatTypes.
 // static
 Clipboard::FormatType Clipboard::GetFormatType(
     const std::string& format_string) {
   return FormatType(
       ::RegisterClipboardFormat(base::ASCIIToWide(format_string).c_str()));
 }
 
@@ skipping 122 matching lines @@
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(
       FormatType,
       type,
       (::RegisterClipboardFormat(L"Chromium Pepper MIME Data Format")));
   return type;
 }
 
-// Clipboard implementation.
-Clipboard::Clipboard() {
+// Clipboard factory method.
+// static
+Clipboard* Clipboard::Create() {
+  return new ClipboardWin;
+}
+
+// ClipboardWin implementation.
+ClipboardWin::ClipboardWin() {
   if (base::MessageLoopForUI::IsCurrent())
     clipboard_owner_.reset(new base::win::MessageWindow());
 }
 
-Clipboard::~Clipboard() {
+ClipboardWin::~ClipboardWin() {
 }
 
-uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
+uint64 ClipboardWin::GetSequenceNumber(ClipboardType type) {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   return ::GetClipboardSequenceNumber();
 }
 
-bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
-                                  ClipboardType type) const {
+bool ClipboardWin::IsFormatAvailable(const Clipboard::FormatType& format,
+                                     ClipboardType type) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
-  return ::IsClipboardFormatAvailable(format.ToUINT()) != FALSE;
+  return ::IsClipboardFormatAvailable(format.ToFormatEtc().cfFormat) != FALSE;
 }
 
-void Clipboard::Clear(ClipboardType type) {
+void ClipboardWin::Clear(ClipboardType type) {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   ::EmptyClipboard();
 }
 
-void Clipboard::ReadAvailableTypes(ClipboardType type,
-                                   std::vector<base::string16>* types,
-                                   bool* contains_filenames) const {
+void ClipboardWin::ReadAvailableTypes(ClipboardType type,
+                                      std::vector<base::string16>* types,
+                                      bool* contains_filenames) const {
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
   types->clear();
-  if (::IsClipboardFormatAvailable(GetPlainTextFormatType().ToUINT()))
+  if (::IsClipboardFormatAvailable(
+          GetPlainTextFormatType().ToFormatEtc().cfFormat))
     types->push_back(base::UTF8ToUTF16(kMimeTypeText));
-  if (::IsClipboardFormatAvailable(GetHtmlFormatType().ToUINT()))
+  if (::IsClipboardFormatAvailable(GetHtmlFormatType().ToFormatEtc().cfFormat))
     types->push_back(base::UTF8ToUTF16(kMimeTypeHTML));
-  if (::IsClipboardFormatAvailable(GetRtfFormatType().ToUINT()))
+  if (::IsClipboardFormatAvailable(GetRtfFormatType().ToFormatEtc().cfFormat))
     types->push_back(base::UTF8ToUTF16(kMimeTypeRTF));
   if (::IsClipboardFormatAvailable(CF_DIB))
     types->push_back(base::UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE hdata = ::GetClipboardData(GetWebCustomDataFormatType().ToUINT());
+  HANDLE hdata =
+      ::GetClipboardData(GetWebCustomDataFormatType().ToFormatEtc().cfFormat);
   if (!hdata)
     return;
 
   ReadCustomDataTypes(::GlobalLock(hdata), ::GlobalSize(hdata), types);
   ::GlobalUnlock(hdata);
 }
 
-void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
+void ClipboardWin::ReadText(ClipboardType type, base::string16* result) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   if (!result) {
     NOTREACHED();
     return;
   }
 
   result->clear();
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   HANDLE data = ::GetClipboardData(CF_UNICODETEXT);
   if (!data)
     return;
 
   result->assign(static_cast<const base::char16*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 }
 
-void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
+void ClipboardWin::ReadAsciiText(ClipboardType type,
+                                 std::string* result) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   if (!result) {
     NOTREACHED();
     return;
   }
 
   result->clear();
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   HANDLE data = ::GetClipboardData(CF_TEXT);
   if (!data)
     return;
 
   result->assign(static_cast<const char*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 }
 
-void Clipboard::ReadHTML(ClipboardType type,
-                         base::string16* markup,
-                         std::string* src_url,
-                         uint32* fragment_start,
-                         uint32* fragment_end) const {
+void ClipboardWin::ReadHTML(ClipboardType type,
+                            base::string16* markup,
+                            std::string* src_url,
+                            uint32* fragment_start,
+                            uint32* fragment_end) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
 
   markup->clear();
   // TODO(dcheng): Remove these checks, I don't think they should be optional.
   DCHECK(src_url);
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE data = ::GetClipboardData(GetHtmlFormatType().ToUINT());
+  HANDLE data = ::GetClipboardData(GetHtmlFormatType().ToFormatEtc().cfFormat);
   if (!data)
     return;
 
   std::string cf_html(static_cast<const char*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 
   size_t html_start = std::string::npos;
   size_t start_index = std::string::npos;
   size_t end_index = std::string::npos;
   ClipboardUtil::CFHtmlExtractMetadata(cf_html, src_url, &html_start,
@@ skipping 11 matching lines @@
 
   std::vector<size_t> offsets;
   offsets.push_back(start_index - html_start);
   offsets.push_back(end_index - html_start);
   markup->assign(base::UTF8ToUTF16AndAdjustOffsets(cf_html.data() + html_start,
                                                    &offsets));
   *fragment_start = base::checked_cast<uint32>(offsets[0]);
   *fragment_end = base::checked_cast<uint32>(offsets[1]);
 }
 
-void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
+void ClipboardWin::ReadRTF(ClipboardType type, std::string* result) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
 
   ReadData(GetRtfFormatType(), result);
 }
 
-SkBitmap Clipboard::ReadImage(ClipboardType type) const {
+SkBitmap ClipboardWin::ReadImage(ClipboardType type) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return SkBitmap();
 
   // We use a DIB rather than a DDB here since ::GetObject() with the
   // HBITMAP returned from ::GetClipboardData(CF_BITMAP) always reports a color
   // depth of 32bpp.
@@ skipping 49 matching lines @@
     bool has_invalid_alpha_channel = bitmap->bmiHeader.biBitCount < 32 ||
         BitmapHasInvalidPremultipliedColors(device_bitmap);
     if (has_invalid_alpha_channel) {
       MakeBitmapOpaque(device_bitmap);
     }
   }
 
   return canvas.ExtractImageRep().sk_bitmap();
 }
 
-void Clipboard::ReadCustomData(ClipboardType clipboard_type,
-                               const base::string16& type,
-                               base::string16* result) const {
+void ClipboardWin::ReadCustomData(ClipboardType clipboard_type,
+                                  const base::string16& type,
+                                  base::string16* result) const {
   DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE);
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE hdata = ::GetClipboardData(GetWebCustomDataFormatType().ToUINT());
+  HANDLE hdata =
+      ::GetClipboardData(GetWebCustomDataFormatType().ToFormatEtc().cfFormat);
   if (!hdata)
     return;
 
   ReadCustomDataForType(::GlobalLock(hdata), ::GlobalSize(hdata), type, result);
   ::GlobalUnlock(hdata);
 }
 
-void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
+void ClipboardWin::ReadBookmark(base::string16* title, std::string* url) const {
   if (title)
     title->clear();
 
   if (url)
     url->clear();
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE data = ::GetClipboardData(GetUrlWFormatType().ToUINT());
+  HANDLE data = ::GetClipboardData(GetUrlWFormatType().ToFormatEtc().cfFormat);
   if (!data)
     return;
 
   base::string16 bookmark(static_cast<const base::char16*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 
   ParseBookmarkClipboardFormat(bookmark, title, url);
 }
 
-void Clipboard::ReadData(const FormatType& format, std::string* result) const {
+void ClipboardWin::ReadData(const FormatType& format,
+                            std::string* result) const {
   if (!result) {
     NOTREACHED();
     return;
   }
 
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE data = ::GetClipboardData(format.ToUINT());
+  HANDLE data = ::GetClipboardData(format.ToFormatEtc().cfFormat);
   if (!data)
     return;
 
   result->assign(static_cast<const char*>(::GlobalLock(data)),
                  ::GlobalSize(data));
   ::GlobalUnlock(data);
 }
 
-// static
-void Clipboard::ParseBookmarkClipboardFormat(const base::string16& bookmark,
-                                             base::string16* title,
-                                             std::string* url) {
-  const base::string16 kDelim = base::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 != base::string16::npos) {
-      *url = base::UTF16ToUTF8(
-          bookmark.substr(url_start, base::string16::npos));
-    }
-  }
-}
-
-void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
+void ClipboardWin::WriteObjects(ClipboardType type, const ObjectMap& objects) {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
 
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   ::EmptyClipboard();
 
-  for (ObjectMap::const_iterator iter = objects.begin();
-       iter != objects.end(); ++iter) {
+  for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
+       ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 }
 
-void Clipboard::WriteText(const char* text_data, size_t text_len) {
+void ClipboardWin::WriteText(const char* text_data, size_t text_len) {
   base::string16 text;
   base::UTF8ToUTF16(text_data, text_len, &text);
   HGLOBAL glob = CreateGlobalData(text);
 
   WriteToClipboard(CF_UNICODETEXT, glob);
 }
 
-void Clipboard::WriteHTML(const char* markup_data,
-                          size_t markup_len,
-                          const char* url_data,
-                          size_t url_len) {
+void ClipboardWin::WriteHTML(const char* markup_data,
+                             size_t markup_len,
+                             const char* url_data,
+                             size_t url_len) {
   std::string markup(markup_data, markup_len);
   std::string url;
 
   if (url_len > 0)
     url.assign(url_data, url_len);
 
   std::string html_fragment = ClipboardUtil::HtmlToCFHtml(markup, url);
   HGLOBAL glob = CreateGlobalData(html_fragment);
 
-  WriteToClipboard(Clipboard::GetHtmlFormatType().ToUINT(), glob);
+  WriteToClipboard(Clipboard::GetHtmlFormatType().ToFormatEtc().cfFormat, glob);
 }
 
-void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
+void ClipboardWin::WriteRTF(const char* rtf_data, size_t data_len) {
   WriteData(GetRtfFormatType(), rtf_data, data_len);
 }
 
-void Clipboard::WriteBookmark(const char* title_data,
-                              size_t title_len,
-                              const char* url_data,
-                              size_t url_len) {
+void ClipboardWin::WriteBookmark(const char* title_data,
+                                 size_t title_len,
+                                 const char* url_data,
+                                 size_t url_len) {
   std::string bookmark(title_data, title_len);
   bookmark.append(1, L'\n');
   bookmark.append(url_data, url_len);
 
   base::string16 wide_bookmark = base::UTF8ToWide(bookmark);
   HGLOBAL glob = CreateGlobalData(wide_bookmark);
 
-  WriteToClipboard(GetUrlWFormatType().ToUINT(), glob);
+  WriteToClipboard(GetUrlWFormatType().ToFormatEtc().cfFormat, glob);
 }
 
-void Clipboard::WriteWebSmartPaste() {
+void ClipboardWin::WriteWebSmartPaste() {
   DCHECK(clipboard_owner_->hwnd() != NULL);
-  ::SetClipboardData(GetWebKitSmartPasteFormatType().ToUINT(), NULL);
+  ::SetClipboardData(GetWebKitSmartPasteFormatType().ToFormatEtc().cfFormat,
+                     NULL);
 }
 
-void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
+void ClipboardWin::WriteBitmap(const SkBitmap& bitmap) {
   HDC dc = ::GetDC(NULL);
 
   // This doesn't actually cost us a memcpy when the bitmap comes from the
   // renderer as we load it into the bitmap using setPixels which just sets a
   // pointer.  Someone has to memcpy it into GDI, it might as well be us here.
 
   // TODO(darin): share data in gfx/bitmap_header.cc somehow
   BITMAPINFO bm_info = {0};
   bm_info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
   bm_info.bmiHeader.biWidth = bitmap.width();
   bm_info.bmiHeader.biHeight = -bitmap.height();  // sets vertical orientation
   bm_info.bmiHeader.biPlanes = 1;
   bm_info.bmiHeader.biBitCount = 32;
   bm_info.bmiHeader.biCompression = BI_RGB;
 
   // ::CreateDIBSection allocates memory for us to copy our bitmap into.
   // Unfortunately, we can't write the created bitmap to the clipboard,
   // (see http://msdn2.microsoft.com/en-us/library/ms532292.aspx)
-  void *bits;
+  void* bits;
   HBITMAP source_hbitmap =
       ::CreateDIBSection(dc, &bm_info, DIB_RGB_COLORS, &bits, NULL, 0);
 
   if (bits && source_hbitmap) {
     {
       SkAutoLockPixels bitmap_lock(bitmap);
       // Copy the bitmap out of shared memory and into GDI
       memcpy(bits, bitmap.getPixels(), bitmap.getSize());
     }
 
     // Now we have an HBITMAP, we can write it to the clipboard
     WriteBitmapFromHandle(source_hbitmap,
                           gfx::Size(bitmap.width(), bitmap.height()));
   }
 
   ::DeleteObject(source_hbitmap);
   ::ReleaseDC(NULL, dc);
 }
 
-void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap,
-                                      const gfx::Size& size) {
+void ClipboardWin::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(format.ToFormatEtc().cfFormat, hdata);
+}
+
+void ClipboardWin::WriteBitmapFromHandle(HBITMAP source_hbitmap,
+                                         const gfx::Size& size) {
   // We would like to just call ::SetClipboardData on the source_hbitmap,
   // but that bitmap might not be of a sort we can write to the clipboard.
   // For this reason, we create a new bitmap, copy the bits over, and then
   // write that to the clipboard.
 
   HDC dc = ::GetDC(NULL);
   HDC compatible_dc = ::CreateCompatibleDC(NULL);
   HDC source_dc = ::CreateCompatibleDC(NULL);
 
   // This is the HBITMAP we will eventually write to the clipboard
   HBITMAP hbitmap = ::CreateCompatibleBitmap(dc, size.width(), size.height());
   if (!hbitmap) {
     // Failed to create the bitmap
     ::DeleteDC(compatible_dc);
     ::DeleteDC(source_dc);
     ::ReleaseDC(NULL, dc);
     return;
   }
 
   HBITMAP old_hbitmap = (HBITMAP)SelectObject(compatible_dc, hbitmap);
   HBITMAP old_source = (HBITMAP)SelectObject(source_dc, source_hbitmap);
 
   // Now we need to blend it into an HBITMAP we can place on the clipboard
   BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
-  ::GdiAlphaBlend(compatible_dc, 0, 0, size.width(), size.height(),
-                  source_dc, 0, 0, size.width(), size.height(), bf);
+  ::GdiAlphaBlend(compatible_dc,
+                  0,
+                  0,
+                  size.width(),
+                  size.height(),
+                  source_dc,
+                  0,
+                  0,
+                  size.width(),
+                  size.height(),
+                  bf);
 
   // Clean up all the handles we just opened
   ::SelectObject(compatible_dc, old_hbitmap);
   ::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 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(format.ToUINT(), hdata);
-}
-
-void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) {
+void ClipboardWin::WriteToClipboard(unsigned int format, HANDLE handle) {
   DCHECK(clipboard_owner_->hwnd() != NULL);
   if (handle && !::SetClipboardData(format, handle)) {
     DCHECK(ERROR_CLIPBOARD_NOT_OPEN != GetLastError());
     FreeData(format, handle);
   }
 }
 
-// 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 {
+HWND ClipboardWin::GetClipboardWindow() const {
   if (!clipboard_owner_)
     return NULL;
 
   if (clipboard_owner_->hwnd() == NULL)
     clipboard_owner_->Create(base::Bind(&ClipboardOwnerWndProc));
 
   return clipboard_owner_->hwnd();
 }
 
 }  // namespace ui