More removal of GTK code.

ui/base/clipboard/clipboard_unittest.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.
 
 #include "build/build_config.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 141 matching lines @@
     clipboard_writer.WriteRTF(rtf);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetRtfFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   std::string result;
   clipboard().ReadRTF(CLIPBOARD_TYPE_COPY_PASTE, &result);
   EXPECT_EQ(rtf, result);
 }
 
-#if defined(TOOLKIT_GTK)

[dcheng, 2014/04/11 21:49:50]

Shouldn't this test run on Linux Aura?

[Elliot Glaysher, 2014/04/11 22:16:44]

Done.

-TEST_F(ClipboardTest, MultipleBufferTest) {
-  base::string16 text(ASCIIToUTF16("Standard")), text_result;
-  base::string16 markup(ASCIIToUTF16("<string>Selection</string>"));
-  std::string url("http://www.example.com/"), url_result;
-
-  {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
-    clipboard_writer.WriteText(text);
-  }
-
-  {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_SELECTION);
-    clipboard_writer.WriteHTML(markup, url);
-  }
-
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
-                                            CLIPBOARD_TYPE_COPY_PASTE));
-  EXPECT_FALSE(clipboard().IsFormatAvailable(
-      Clipboard::GetPlainTextFormatType(),
-      CLIPBOARD_TYPE_SELECTION));
-
-  EXPECT_FALSE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                             CLIPBOARD_TYPE_COPY_PASTE));
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            CLIPBOARD_TYPE_SELECTION));
-
-  clipboard().ReadText(CLIPBOARD_TYPE_COPY_PASTE, &text_result);
-  EXPECT_EQ(text, text_result);
-
-  uint32 ignored;
-  base::string16 markup_result;
-  clipboard().ReadHTML(CLIPBOARD_TYPE_SELECTION,
-                       &markup_result,
-                       &url_result,
-                       &ignored,
-                       &ignored);
-  EXPECT_PRED2(MarkupMatches, markup, markup_result);
-}
-#endif
-
 TEST_F(ClipboardTest, TrickyHTMLTest) {
   base::string16 markup(ASCIIToUTF16("<em>Bye!<!--EndFragment --></em>")),
       markup_result;
   std::string url, url_result;
   base::string16 plain(ASCIIToUTF16("Bye!")), plain_result;
 
   {
     ScopedClipboardWriter clipboard_writer(&clipboard(),
                                            CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(plain);
@@ skipping 32 matching lines @@
   clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &markup_result, &url_result,
                        &fragment_start, &fragment_end);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
   EXPECT_EQ(url, url_result);
   // Make sure that fragment indices were adjusted when converting.
   EXPECT_EQ(36, fragment_start);
   EXPECT_EQ(52, fragment_end);
 }
 #endif  // defined(OS_WIN)
 
-#if defined(TOOLKIT_GTK)
-// Regression test for crbug.com/56298 (pasting empty HTML crashes Linux).
-TEST_F(ClipboardTest, EmptyHTMLTest) {
-  // ScopedClipboardWriter doesn't let us write empty data to the clipboard.
-  clipboard().clipboard_data_ = new Clipboard::TargetMap();
-  // The 1 is so the compiler doesn't warn about allocating an empty array.
-  char* empty = new char[1];
-  clipboard().InsertMapping("text/html", empty, 0U);
-  clipboard().SetGtkClipboard(CLIPBOARD_TYPE_COPY_PASTE);
-
-  EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
-                                            CLIPBOARD_TYPE_COPY_PASTE));
-  base::string16 markup_result;
-  std::string url_result;
-  uint32 ignored;
-  clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &markup_result, &url_result,
-                       &ignored, &ignored);
-  EXPECT_PRED2(MarkupMatches, base::string16(), markup_result);
-}
-#endif
-
 // TODO(estade): Port the following test (decide what target we use for urls)
 #if !defined(OS_POSIX) || defined(OS_MACOSX)
 TEST_F(ClipboardTest, BookmarkTest) {
   base::string16 title(ASCIIToUTF16("The Example Company")), title_result;
   std::string url("http://www.example.com/"), url_result;
 
   {
     ScopedClipboardWriter clipboard_writer(&clipboard(),
                                            CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteBookmark(title, url);
@@ skipping 119 matching lines @@
   EXPECT_TRUE(clipboard->IsFormatAvailable(Clipboard::GetBitmapFormatType(),
                                            CLIPBOARD_TYPE_COPY_PASTE));
   const SkBitmap& image = clipboard->ReadImage(CLIPBOARD_TYPE_COPY_PASTE);
   EXPECT_EQ(size, gfx::Size(image.width(), image.height()));
   SkAutoLockPixels image_lock(image);
   for (int j = 0; j < image.height(); ++j) {
     const uint32* row_address = image.getAddr32(0, j);
     for (int i = 0; i < image.width(); ++i) {
       int offset = i + j * image.width();
       uint32 pixel = SkPreMultiplyColor(bitmap_data[offset]);
-#if defined(TOOLKIT_GTK)
-      // Non-Aura GTK doesn't support alpha transparency. Instead, the alpha
-      // channel is always set to 0xFF - see http://crbug.com/154573.
-      // However, since we premultiplied above, we must also premultiply here
-      // before unpremultiplying and setting alpha to 0xFF; otherwise, the
-      // results will not match GTK's.
-      EXPECT_EQ(
-          SkUnPreMultiply::PMColorToColor(pixel) | 0xFF000000, row_address[i])
-          << "i = " << i << ", j = " << j;
-#else
       EXPECT_EQ(pixel, row_address[i])
           << "i = " << i << ", j = " << j;
-#endif  // defined(TOOLKIT_GTK)
     }
   }
 }
 
 TEST_F(ClipboardTest, SharedBitmapTest) {
   const uint32 fake_bitmap_1[] = {
     0x46155189, 0xF6A55C8D, 0x79845674, 0xFA57BD89,
     0x78FD46AE, 0x87C64F5A, 0x36EDC5AF, 0x4378F568,
     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
   };
@@ skipping 395 matching lines @@
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
 
   // Make sure the text is what we inserted while simulating the other app
   std::string contents;
   clipboard().ReadAsciiText(CLIPBOARD_TYPE_COPY_PASTE, &contents);
   EXPECT_EQ(contents, new_value);
 }
 #endif
 }  // namespace ui