Move clipboard-related webkit_glue embedder functions into a ClipboardClient interface.

webkit/glue/webclipboard_impl.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.
 
 #include "webkit/glue/webclipboard_impl.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
@@ skipping 44 matching lines @@
   markup.append("\"");
   if (!title.isEmpty()) {
     markup.append(" alt=\"");
     markup.append(net::EscapeForHTML(UTF16ToUTF8(title)));
     markup.append("\"");
   }
   markup.append("/>");
   return markup;
 }
 
+WebClipboardImpl::WebClipboardImpl(ClipboardClient* client)
+    : client_(client) {
+}
+
 WebClipboardImpl::~WebClipboardImpl() {
 }
 
 uint64 WebClipboardImpl::getSequenceNumber() {
   return sequenceNumber(BufferStandard);
 }
 
 uint64 WebClipboardImpl::sequenceNumber(Buffer buffer) {
   ui::Clipboard::Buffer buffer_type;
   if (!ConvertBufferType(buffer, &buffer_type))
     return 0;
 
-  return ClipboardGetSequenceNumber(buffer_type);
+  return client_->GetSequenceNumber(buffer_type);
 }
 
 bool WebClipboardImpl::isFormatAvailable(Format format, Buffer buffer) {
   ui::Clipboard::FormatType format_type;
   ui::Clipboard::Buffer buffer_type;
 
   if (!ConvertBufferType(buffer, &buffer_type))
     return false;
 
   switch (format) {
     case FormatPlainText:
-      return ClipboardIsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
+      return client_->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
                                         buffer_type) ||
-          ClipboardIsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
+          client_->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
                                      buffer_type);
     case FormatHTML:
       format_type = ui::Clipboard::GetHtmlFormatType();
       break;
     case FormatSmartPaste:
       format_type = ui::Clipboard::GetWebKitSmartPasteFormatType();
       break;
     case FormatBookmark:
 #if defined(OS_WIN) || defined(OS_MACOSX)
       format_type = ui::Clipboard::GetUrlWFormatType();
       break;
 #endif
     default:
       NOTREACHED();
       return false;
   }
 
-  return ClipboardIsFormatAvailable(format_type, buffer_type);
+  return client_->IsFormatAvailable(format_type, buffer_type);
 }
 
 WebVector<WebString> WebClipboardImpl::readAvailableTypes(
     Buffer buffer, bool* contains_filenames) {
   ui::Clipboard::Buffer buffer_type;
   std::vector<string16> types;
   if (ConvertBufferType(buffer, &buffer_type)) {
-    ClipboardReadAvailableTypes(buffer_type, &types, contains_filenames);
+    client_->ReadAvailableTypes(buffer_type, &types, contains_filenames);
   }
   return types;
 }
 
 WebString WebClipboardImpl::readPlainText(Buffer buffer) {
   ui::Clipboard::Buffer buffer_type;
   if (!ConvertBufferType(buffer, &buffer_type))
     return WebString();
 
-  if (ClipboardIsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
+  if (client_->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
                                  buffer_type)) {
     string16 text;
-    ClipboardReadText(buffer_type, &text);
+    client_->ReadText(buffer_type, &text);
     if (!text.empty())
       return text;
   }
 
-  if (ClipboardIsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
+  if (client_->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(),
                                  buffer_type)) {
     std::string text;
-    ClipboardReadAsciiText(buffer_type, &text);
+    client_->ReadAsciiText(buffer_type, &text);
     if (!text.empty())
       return ASCIIToUTF16(text);
   }
 
   return WebString();
 }
 
 WebString WebClipboardImpl::readHTML(Buffer buffer, WebURL* source_url,
                                      unsigned* fragment_start,
                                      unsigned* fragment_end) {
   ui::Clipboard::Buffer buffer_type;
   if (!ConvertBufferType(buffer, &buffer_type))
     return WebString();
 
   string16 html_stdstr;
   GURL gurl;
-  ClipboardReadHTML(buffer_type, &html_stdstr, &gurl,
+  client_->ReadHTML(buffer_type, &html_stdstr, &gurl,
                     static_cast<uint32*>(fragment_start),
                     static_cast<uint32*>(fragment_end));
   *source_url = gurl;
   return html_stdstr;
 }
 
 WebData WebClipboardImpl::readImage(Buffer buffer) {
   ui::Clipboard::Buffer buffer_type;
   if (!ConvertBufferType(buffer, &buffer_type))
     return WebData();
 
   std::string png_data;
-  ClipboardReadImage(buffer_type, &png_data);
+  client_->ReadImage(buffer_type, &png_data);
   return WebData(png_data);
 }
 
 void WebClipboardImpl::writeHTML(
     const WebString& html_text, const WebURL& source_url,
     const WebString& plain_text, bool write_smart_paste) {
-  ScopedClipboardWriterGlue scw(ClipboardGetClipboard());
+  ScopedClipboardWriterGlue scw(client_);
   scw.WriteHTML(html_text, source_url.spec());
   scw.WriteText(plain_text);
 
   if (write_smart_paste)
     scw.WriteWebSmartPaste();
 }
 
 void WebClipboardImpl::writePlainText(const WebString& plain_text) {
-  ScopedClipboardWriterGlue scw(ClipboardGetClipboard());
+  ScopedClipboardWriterGlue scw(client_);
   scw.WriteText(plain_text);
 }
 
 void WebClipboardImpl::writeURL(const WebURL& url, const WebString& title) {
-  ScopedClipboardWriterGlue scw(ClipboardGetClipboard());
+  ScopedClipboardWriterGlue scw(client_);
 
   scw.WriteBookmark(title, url.spec());
   scw.WriteHTML(UTF8ToUTF16(URLToMarkup(url, title)), "");
   scw.WriteText(UTF8ToUTF16(std::string(url.spec())));
 }
 
 void WebClipboardImpl::writeImage(
     const WebImage& image, const WebURL& url, const WebString& title) {
-  ScopedClipboardWriterGlue scw(ClipboardGetClipboard());
+  ScopedClipboardWriterGlue scw(client_);
 
   if (!image.isNull()) {
 #if WEBKIT_USING_SKIA
     const SkBitmap& bitmap = image.getSkBitmap();
 #elif WEBKIT_USING_CG
     const SkBitmap& bitmap = gfx::CGImageToSkBitmap(image.getCGImageRef());
 #endif
     SkAutoLockPixels locked(bitmap);
     scw.WriteBitmapFromPixels(bitmap.getPixels(), image.size());
   }
@@ skipping 10 matching lines @@
     // http://crbug.com/33016 for details.
     scw.WriteHTML(UTF8ToUTF16(URLToImageMarkup(url, title)), "");
 #endif
   }
 }
 
 void WebClipboardImpl::writeDataObject(const WebDragData& data) {
   // TODO(dcheng): This actually results in a double clear of the clipboard.
   // Once in WebKit, and once here when the clipboard writer goes out of scope.
   // The same is true of the other WebClipboard::write* methods.
-  ScopedClipboardWriterGlue scw(ClipboardGetClipboard());
+  ScopedClipboardWriterGlue scw(client_);
 
   // TODO(dcheng): Properly support text/uri-list here.
   scw.WriteText(data.plainText());
   scw.WriteHTML(data.htmlText(), "");
 }
 
 bool WebClipboardImpl::ConvertBufferType(Buffer buffer,
                                          ui::Clipboard::Buffer* result) {
   switch (buffer) {
     case BufferStandard:
       *result = ui::Clipboard::BUFFER_STANDARD;
       break;
     case BufferSelection:
 #if defined(USE_X11) && !defined(USE_AURA)
       *result = ui::Clipboard::BUFFER_SELECTION;
       break;
 #endif
     default:
       NOTREACHED();
       return false;
   }
   return true;
 }
 
 }  // namespace webkit_glue