* Remove windows-ism from pasteboard code and move to using

ChromiumBridge for clipboard methods.  Also did some cleanup
of lingering webkit_glue code in ClipboardChromium.

Review URL: http://codereview.chromium.org/10285

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@5213 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 202 insertions, 14 deletions

diff --git a/webkit/glue/chromium_bridge_impl.cc b/webkit/glue/chromium_bridge_impl.cc
index 0289f81..32f38a2 100644
--- a/webkit/glue/chromium_bridge_impl.cc
+++ b/webkit/glue/chromium_bridge_impl.cc
@@ -5,46 +5,175 @@
 #include "config.h"
 #include "ChromiumBridge.h"
 
+#include "ClipboardUtilitiesChromium.h"
 #include "Cursor.h"
 #include "Frame.h"
 #include "FrameView.h"
 #include "HostWindow.h"
+#include "KURL.h"
+#include "NativeImageSkia.h"
 #include "Page.h"
+#include "PasteboardPrivate.h"
+#include "PlatformString.h"
 #include "PlatformWidget.h"
 #include "ScrollView.h"
 #include "Widget.h"
 
 #undef LOG
+#include "base/clipboard.h"
+#include "base/string_util.h"
 #include "webkit/glue/chrome_client_impl.h"
 #include "webkit/glue/glue_util.h"
+#include "webkit/glue/scoped_clipboard_writer_glue.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webview_impl.h"
 #include "webkit/glue/webview_delegate.h"
 
-namespace WebCore {
+namespace {
 
-static PlatformWidget ToPlatform(Widget* widget) {
+PlatformWidget ToPlatform(WebCore::Widget* widget) {
   return widget ? widget->root()->hostWindow()->platformWindow() : 0;
 }
 
-static ChromeClientImpl* ToChromeClient(Widget* widget) {
-  FrameView* view;
+ChromeClientImpl* ToChromeClient(WebCore::Widget* widget) {
+  WebCore::FrameView* view;
   if (widget->isFrameView()) {
-    view = static_cast<FrameView*>(widget);
+    view = static_cast<WebCore::FrameView*>(widget);
   } else if (widget->parent() && widget->parent()->isFrameView()) {
-    view = static_cast<FrameView*>(widget->parent());
+    view = static_cast<WebCore::FrameView*>(widget->parent());
   } else {
     return NULL;
   }
 
-  Page* page = view->frame() ? view->frame()->page() : NULL;
+  WebCore::Page* page = view->frame() ? view->frame()->page() : NULL;
   if (!page)
     return NULL;
 
   return static_cast<ChromeClientImpl*>(page->chrome()->client());
 }
 
+std::wstring UrlToImageMarkup(const WebCore::KURL& url,
+                              const WebCore::String& alt_str) {
+  std::wstring markup(L"<img src=\"");
+  markup.append(webkit_glue::StringToStdWString(url.string()));
+  markup.append(L"\"");
+  if (!alt_str.isEmpty()) {
+    markup.append(L" alt=\"");
+    std::wstring alt_stdstr = webkit_glue::StringToStdWString(alt_str);
+    ReplaceSubstringsAfterOffset(&alt_stdstr, 0, L"\"", L"&quot;");
+    markup.append(alt_stdstr);
+    markup.append(L"\"");
+  }
+  markup.append(L"/>");
+  return markup;
+}
+
+}  // namespace
+
+namespace WebCore {
+
+bool ChromiumBridge::clipboardIsFormatAvailable(
+    PasteboardPrivate::ClipboardFormat format) {
+  switch (format) {
+    case PasteboardPrivate::HTMLFormat:
+      return webkit_glue::ClipboardIsFormatAvailable(
+          ::Clipboard::GetHtmlFormatType());
+
+    case PasteboardPrivate::BookmarkFormat:
+#if defined(OS_WIN) || defined(OS_MACOSX)
+      return webkit_glue::ClipboardIsFormatAvailable(
+          ::Clipboard::GetUrlWFormatType());
+#endif
+
+#if defined(OS_WIN)
+    // TODO(tc): This should work for linux/mac too.
+    case PasteboardPrivate::WebSmartPasteFormat:
+      return webkit_glue::ClipboardIsFormatAvailable(
+          ::Clipboard::GetWebKitSmartPasteFormatType());
+#endif
+
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+String ChromiumBridge::clipboardReadPlainText() {
+  if (webkit_glue::ClipboardIsFormatAvailable(
+      ::Clipboard::GetPlainTextWFormatType())) {
+    std::wstring text;
+    webkit_glue::ClipboardReadText(&text);
+    if (!text.empty())
+      return webkit_glue::StdWStringToString(text);
+  }
+
+  if (webkit_glue::ClipboardIsFormatAvailable(
+      ::Clipboard::GetPlainTextFormatType())) {
+    std::string text;
+    webkit_glue::ClipboardReadAsciiText(&text);
+    if (!text.empty())
+      return webkit_glue::StdStringToString(text);
+  }
+
+  return String();
+}
+
+void ChromiumBridge::clipboardReadHTML(String* html, KURL* url) {
+  std::wstring html_stdstr;
+  GURL gurl;
+  webkit_glue::ClipboardReadHTML(&html_stdstr, &gurl);
+  *html = webkit_glue::StdWStringToString(html_stdstr);
+  *url = webkit_glue::GURLToKURL(gurl);
+}
+
+void ChromiumBridge::clipboardWriteSelection(const String& html,
+                                             const KURL& url,
+                                             const String& plain_text,
+                                             bool can_smart_copy_or_delete) {
+  ScopedClipboardWriterGlue scw(webkit_glue::ClipboardGetClipboard());
+  scw.WriteHTML(webkit_glue::StringToStdWString(html),
+                webkit_glue::CStringToStdString(url.utf8String()));
+  scw.WriteText(webkit_glue::StringToStdWString(plain_text));
+
+#if defined(OS_WIN)
+  if (can_smart_copy_or_delete)
+    scw.WriteWebSmartPaste();
+#endif
+}
+
+void ChromiumBridge::clipboardWriteURL(const KURL& url, const String& title) {
+  ScopedClipboardWriterGlue scw(webkit_glue::ClipboardGetClipboard());
+
+  GURL gurl = webkit_glue::KURLToGURL(url);
+  scw.WriteBookmark(webkit_glue::StringToStdWString(title), gurl.spec());
+
+  std::wstring link(webkit_glue::StringToStdWString(urlToMarkup(url, title)));
+  scw.WriteHTML(link, "");
+
+  scw.WriteText(ASCIIToWide(gurl.spec()));
+}
+
+void ChromiumBridge::clipboardWriteImage(const NativeImageSkia* bitmap,
+    const KURL& url, const String& title) {
+  ScopedClipboardWriterGlue scw(webkit_glue::ClipboardGetClipboard());
+
+#if defined(OS_WIN)
+  if (bitmap)
+    scw.WriteBitmap(*bitmap);
+#endif
+  if (!url.isEmpty()) {
+    GURL gurl = webkit_glue::KURLToGURL(url);
+    scw.WriteBookmark(webkit_glue::StringToStdWString(title), gurl.spec());
+
+    scw.WriteHTML(UrlToImageMarkup(url, title), "");
+
+    scw.WriteText(ASCIIToWide(gurl.spec()));
+  }
+}
+
+// 
+
 // Cookies --------------------------------------------------------------------
 
 void ChromiumBridge::setCookies(
diff --git a/webkit/glue/clipboard_conversion.cc b/webkit/glue/clipboard_conversion.cc
index 9df3f59..0c690c0 100644
--- a/webkit/glue/clipboard_conversion.cc
+++ b/webkit/glue/clipboard_conversion.cc
@@ -9,10 +9,10 @@
 #include "build/build_config.h"
 
 #include "ChromiumDataObject.h"
-#if defined(OS_WIN)
-#include "ClipboardUtilitiesWin.h"
-#endif
+#include "ClipboardUtilitiesChromium.h"
+#include "KURL.h"
 #include "SharedBuffer.h"
+#include <wtf/Vector.h>
 
 #include "webkit/glue/glue_util.h"
 
@@ -20,6 +20,66 @@ namespace {
 
 // TODO(tc): CF_HTML logic should move into the browser process since it only
 // makes sense on Windows.
+#if defined(OS_WIN)
+void append(WTF::Vector<char>& vector, const WebCore::CString& string) {
+  vector.append(string.data(), string.length());
+}
+// Documentation for the CF_HTML format is available at
+// http://msdn.microsoft.com/workshop/networking/clipboard/htmlclipboard.asp
+void markupToCF_HTML(const WebCore::String& markup,
+                     const WebCore::String& src_url,
+                     WTF::Vector<char>& result) {
+  if (markup.isEmpty())
+    return;
+
+  #define MAX_DIGITS 10
+  #define MAKE_NUMBER_FORMAT_1(digits) MAKE_NUMBER_FORMAT_2(digits)
+  #define MAKE_NUMBER_FORMAT_2(digits) "%0" #digits "u"
+  #define NUMBER_FORMAT MAKE_NUMBER_FORMAT_1(MAX_DIGITS)
+
+  static const char* header = "Version:0.9\n"
+      "StartHTML:" NUMBER_FORMAT "\n"
+      "EndHTML:" NUMBER_FORMAT "\n"
+      "StartFragment:" NUMBER_FORMAT "\n"
+      "EndFragment:" NUMBER_FORMAT "\n";
+  static const char* source_url_prefix = "SourceURL:";
+
+  static const char* start_markup = "<HTML>\n<BODY>\n<!--StartFragment-->\n";
+  static const char* end_markup = "\n<!--EndFragment-->\n</BODY>\n</HTML>";
+
+  WebCore::CString source_url_utf8 = (src_url == WebCore::blankURL()) ?
+      "" : src_url.utf8();
+  WebCore::CString markup_utf8 = markup.utf8();
+
+  // calculate offsets
+  size_t start_html_offset = strlen(header) - strlen(NUMBER_FORMAT) * 4 +
+      MAX_DIGITS * 4;
+  if (source_url_utf8.length()) {
+    start_html_offset += strlen(source_url_prefix) +
+        source_url_utf8.length() + 1;
+  }
+  size_t start_fragment_offset = start_html_offset + strlen(start_markup);
+  size_t end_fragment_offset = start_fragment_offset + markup_utf8.length();
+  size_t end_html_offset = end_fragment_offset + strlen(end_markup);
+
+  append(result, WebCore::String::format(header, start_html_offset,
+         end_html_offset, start_fragment_offset, end_fragment_offset).utf8());
+  if (source_url_utf8.length()) {
+    append(result, source_url_prefix);
+    append(result, source_url_utf8);
+    result.append('\n');
+  }
+  append(result, start_markup);
+  append(result, markup_utf8);
+  append(result, end_markup);
+
+  #undef MAX_DIGITS
+  #undef MAKE_NUMBER_FORMAT_1
+  #undef MAKE_NUMBER_FORMAT_2
+  #undef NUMBER_FORMAT
+}
+#endif
+
 std::wstring HTMLToCFHTML(const WebCore::String& html,
                           const WebCore::KURL& url) {
 #if defined(OS_WIN)
diff --git a/webkit/glue/webkit_glue.h b/webkit/glue/webkit_glue.h
index 1d80e86..21754c5 100644
--- a/webkit/glue/webkit_glue.h
+++ b/webkit/glue/webkit_glue.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 
+#include "base/clipboard.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/string16.h"
 #include "webkit/glue/screen_info.h"
@@ -42,7 +43,6 @@ class Frame;
 }
 
 class SkBitmap;
-class Clipboard;
 
 #if defined(OS_MACOSX)
 typedef struct CGImage* CGImageRef;
@@ -196,11 +196,10 @@ HCURSOR LoadCursor(int cursor_id);
 // Glue to access the clipboard.
 
 // Get a clipboard that can be used to construct a ScopedClipboardWriterGlue.
-// TODO(tc): Move base/clipboard.h into the base:: namespace.
-::Clipboard* ClipboardGetClipboard();
+Clipboard* ClipboardGetClipboard();
 
 // Tests whether the clipboard contains a certain format
-bool ClipboardIsFormatAvailable(unsigned int format);
+bool ClipboardIsFormatAvailable(Clipboard::FormatType format);
 
 // Reads UNICODE text from the clipboard, if available.
 void ClipboardReadText(std::wstring* result);