Revert 113040 - Enable custom MIME types in web copy/paste.

ui/base/clipboard/clipboard_gtk.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 "ui/base/clipboard/clipboard.h"
 
 #include <gtk/gtk.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-#include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/base/gtk/gtk_signal.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
 
 namespace {
 
@@ skipping 69 matching lines @@
     } else {
       DLOG(ERROR) << "Unexpected selection atom: " << ev->selection;
     }
   }
   return GDK_FILTER_CONTINUE;
 }
 
 const char kMimeTypeBitmap[] = "image/bmp";
 const char kMimeTypeMozillaURL[] = "text/x-moz-url";
 const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
-// TODO(dcheng): This name is temporary. See crbug.com/106449
-const char kMimeTypeWebCustomData[] = "chromium/x-web-custom-data";
 
 std::string GdkAtomToString(const GdkAtom& atom) {
   gchar* name = gdk_atom_name(atom);
   std::string rv(name);
   g_free(name);
   return rv;
 }
 
 GdkAtom StringToGdkAtom(const std::string& str) {
   return gdk_atom_intern(str.c_str(), FALSE);
@@ skipping 264 matching lines @@
   }
 
   types->clear();
   if (IsFormatAvailable(GetPlainTextFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (IsFormatAvailable(GetHtmlFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
   if (IsFormatAvailable(GetBitmapFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
-
-  GtkClipboard* clipboard = LookupBackingClipboard(buffer);
-  if (!clipboard)
-    return;
-
-  GtkSelectionData* data = gtk_clipboard_wait_for_contents(
-      clipboard, StringToGdkAtom(GetWebCustomDataFormatType()));
-  if (!data)
-    return;
-  ReadCustomDataTypes(data->data, data->length, types);
-  gtk_selection_data_free(data);
 }
 
 
 void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return;
 
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard);
@@ skipping 81 matching lines @@
     cairo_t* context = scoped_platform_paint.GetPlatformSurface();
     gdk_cairo_set_source_pixbuf(context, pixbuf.get(), 0.0, 0.0);
     cairo_paint(context);
   }
   return canvas.ExtractBitmap();
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
-  GtkClipboard* clipboard = LookupBackingClipboard(buffer);
-  if (!clipboard)
-    return;
-
-  GtkSelectionData* data = gtk_clipboard_wait_for_contents(
-      clipboard, StringToGdkAtom(GetWebCustomDataFormatType()));
-  if (!data)
-    return;
-  ReadCustomDataForType(data->data, data->length, type, result);
-  gtk_selection_data_free(data);
+  // TODO(dcheng): Implement this.
+  NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   // TODO(estade): implement this.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const std::string& format, std::string* result) const {
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard_, StringToGdkAtom(format));
@@ skipping 28 matching lines @@
 // static
 Clipboard::FormatType Clipboard::GetBitmapFormatType() {
   return std::string(kMimeTypeBitmap);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
   return std::string(kMimeTypeWebkitSmartPaste);
 }
 
-// static
-Clipboard::FormatType Clipboard::GetWebCustomDataFormatType() {
-  return std::string(kMimeTypeWebCustomData);
-}
-
 void Clipboard::InsertMapping(const char* key,
                               char* data,
                               size_t data_len) {
   DCHECK(clipboard_data_->find(key) == clipboard_data_->end());
   (*clipboard_data_)[key] = std::make_pair(data, data_len);
 }
 
 GtkClipboard* Clipboard::LookupBackingClipboard(Buffer clipboard) const {
   switch (clipboard) {
     case BUFFER_STANDARD:
       return clipboard_;
     case BUFFER_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace ui