Home | History | Annotate | Download | only in clipboard 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "build/build_config.h"
      6 
      7 #include <string>
      8 
      9 #include "base/basictypes.h"
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/pickle.h"
     13 #include "base/strings/string_util.h"
     14 #include "base/strings/utf_string_conversions.h"
     15 #include "testing/gtest/include/gtest/gtest.h"
     16 #include "testing/platform_test.h"
     17 #include "third_party/skia/include/core/SkBitmap.h"
     18 #include "ui/base/clipboard/clipboard.h"
     19 #include "ui/base/clipboard/scoped_clipboard_writer.h"
     20 #include "ui/gfx/size.h"
     21 
     22 #if defined(OS_WIN)
     23 #include "ui/base/clipboard/clipboard_util_win.h"
     24 #endif
     25 
     26 #if defined(OS_ANDROID)
     27 #include "base/android/jni_android.h"
     28 #include "base/android/jni_string.h"
     29 #endif
     30 
     31 namespace ui {
     32 
     33 class ClipboardTest : public PlatformTest {
     34  protected:
     35   Clipboard& clipboard() { return clipboard_; }
     36 
     37  private:
     38   base::MessageLoopForUI message_loop_;
     39   Clipboard clipboard_;
     40 };
     41 
     42 namespace {
     43 
     44 bool MarkupMatches(const string16& expected_markup,
     45                    const string16& actual_markup) {
     46   return actual_markup.find(expected_markup) != string16::npos;
     47 }
     48 
     49 }  // namespace
     50 
     51 TEST_F(ClipboardTest, ClearTest) {
     52   {
     53     ScopedClipboardWriter clipboard_writer(&clipboard(),
     54                                            Clipboard::BUFFER_STANDARD);
     55     clipboard_writer.WriteText(ASCIIToUTF16("clear me"));
     56   }
     57 
     58   clipboard().Clear(Clipboard::BUFFER_STANDARD);
     59 
     60   EXPECT_FALSE(clipboard().IsFormatAvailable(
     61       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
     62   EXPECT_FALSE(clipboard().IsFormatAvailable(
     63       Clipboard::GetPlainTextFormatType(), Clipboard::BUFFER_STANDARD));
     64 }
     65 
     66 TEST_F(ClipboardTest, TextTest) {
     67   string16 text(ASCIIToUTF16("This is a string16!#$")), text_result;
     68   std::string ascii_text;
     69 
     70   {
     71     ScopedClipboardWriter clipboard_writer(&clipboard(),
     72                                            Clipboard::BUFFER_STANDARD);
     73     clipboard_writer.WriteText(text);
     74   }
     75 
     76   EXPECT_TRUE(clipboard().IsFormatAvailable(
     77       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
     78   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
     79                                             Clipboard::BUFFER_STANDARD));
     80   clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
     81 
     82   EXPECT_EQ(text, text_result);
     83   clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
     84   EXPECT_EQ(UTF16ToUTF8(text), ascii_text);
     85 }
     86 
     87 TEST_F(ClipboardTest, HTMLTest) {
     88   string16 markup(ASCIIToUTF16("<string>Hi!</string>")), markup_result;
     89   std::string url("http://www.example.com/"), url_result;
     90 
     91   {
     92     ScopedClipboardWriter clipboard_writer(&clipboard(),
     93                                            Clipboard::BUFFER_STANDARD);
     94     clipboard_writer.WriteHTML(markup, url);
     95   }
     96 
     97   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
     98                                             Clipboard::BUFFER_STANDARD));
     99   uint32 ignored;
    100   clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
    101                      &ignored, &ignored);
    102   EXPECT_PRED2(MarkupMatches, markup, markup_result);
    103 #if defined(OS_WIN)
    104   // TODO(playmobil): It's not clear that non windows clipboards need to support
    105   // this.
    106   EXPECT_EQ(url, url_result);
    107 #endif  // defined(OS_WIN)
    108 }
    109 
    110 TEST_F(ClipboardTest, RTFTest) {
    111   std::string rtf =
    112       "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
    113       "This is some {\\b bold} text.\\par\n"
    114       "}";
    115 
    116   {
    117     ScopedClipboardWriter clipboard_writer(&clipboard(),
    118                                            Clipboard::BUFFER_STANDARD);
    119     clipboard_writer.WriteRTF(rtf);
    120   }
    121 
    122   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetRtfFormatType(),
    123                                             Clipboard::BUFFER_STANDARD));
    124   std::string result;
    125   clipboard().ReadRTF(Clipboard::BUFFER_STANDARD, &result);
    126   EXPECT_EQ(rtf, result);
    127 }
    128 
    129 #if defined(TOOLKIT_GTK)
    130 TEST_F(ClipboardTest, MultipleBufferTest) {
    131   string16 text(ASCIIToUTF16("Standard")), text_result;
    132   string16 markup(ASCIIToUTF16("<string>Selection</string>")), markup_result;
    133   std::string url("http://www.example.com/"), url_result;
    134 
    135   {
    136     ScopedClipboardWriter clipboard_writer(&clipboard(),
    137                                            Clipboard::BUFFER_STANDARD);
    138     clipboard_writer.WriteText(text);
    139   }
    140 
    141   {
    142     ScopedClipboardWriter clipboard_writer(&clipboard(),
    143                                            Clipboard::BUFFER_SELECTION);
    144     clipboard_writer.WriteHTML(markup, url);
    145   }
    146 
    147   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
    148                                             Clipboard::BUFFER_STANDARD));
    149   EXPECT_FALSE(clipboard().IsFormatAvailable(
    150       Clipboard::GetPlainTextFormatType(),
    151       Clipboard::BUFFER_SELECTION));
    152 
    153   EXPECT_FALSE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    154                                              Clipboard::BUFFER_STANDARD));
    155   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    156                                             Clipboard::BUFFER_SELECTION));
    157 
    158   clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
    159   EXPECT_EQ(text, text_result);
    160 
    161   uint32 ignored;
    162   clipboard().ReadHTML(Clipboard::BUFFER_SELECTION, &markup_result, &url_result,
    163                        &ignored, &ignored);
    164   EXPECT_PRED2(MarkupMatches, markup, markup_result);
    165 }
    166 #endif
    167 
    168 TEST_F(ClipboardTest, TrickyHTMLTest) {
    169   string16 markup(ASCIIToUTF16("<em>Bye!<!--EndFragment --></em>")),
    170       markup_result;
    171   std::string url, url_result;
    172 
    173   {
    174     ScopedClipboardWriter clipboard_writer(&clipboard(),
    175                                            Clipboard::BUFFER_STANDARD);
    176     clipboard_writer.WriteHTML(markup, url);
    177   }
    178 
    179   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    180                                             Clipboard::BUFFER_STANDARD));
    181   uint32 ignored;
    182   clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
    183                        &ignored, &ignored);
    184   EXPECT_PRED2(MarkupMatches, markup, markup_result);
    185 #if defined(OS_WIN)
    186   // TODO(playmobil): It's not clear that non windows clipboards need to support
    187   // this.
    188   EXPECT_EQ(url, url_result);
    189 #endif  // defined(OS_WIN)
    190 }
    191 
    192 #if defined(OS_WIN)
    193 TEST_F(ClipboardTest, UniodeHTMLTest) {
    194   string16 markup(UTF8ToUTF16("<div>A \xc3\xb8 \xe6\xb0\xb4</div>")),
    195       markup_result;
    196   std::string url, url_result;
    197 
    198   {
    199     ScopedClipboardWriter clipboard_writer(&clipboard(),
    200                                            Clipboard::BUFFER_STANDARD);
    201     clipboard_writer.WriteHTML(markup, url);
    202   }
    203 
    204   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    205                                             Clipboard::BUFFER_STANDARD));
    206   uint32 fragment_start;
    207   uint32 fragment_end;
    208   clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
    209                        &fragment_start, &fragment_end);
    210   EXPECT_PRED2(MarkupMatches, markup, markup_result);
    211   EXPECT_EQ(url, url_result);
    212   // Make sure that fragment indices were adjusted when converting.
    213   EXPECT_EQ(36, fragment_start);
    214   EXPECT_EQ(52, fragment_end);
    215 }
    216 #endif  // defined(OS_WIN)
    217 
    218 #if defined(TOOLKIT_GTK)
    219 // Regression test for crbug.com/56298 (pasting empty HTML crashes Linux).
    220 TEST_F(ClipboardTest, EmptyHTMLTest) {
    221   // ScopedClipboardWriter doesn't let us write empty data to the clipboard.
    222   clipboard().clipboard_data_ = new Clipboard::TargetMap();
    223   // The 1 is so the compiler doesn't warn about allocating an empty array.
    224   char* empty = new char[1];
    225   clipboard().InsertMapping("text/html", empty, 0U);
    226   clipboard().SetGtkClipboard(Clipboard::BUFFER_STANDARD);
    227 
    228   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    229                                             Clipboard::BUFFER_STANDARD));
    230   string16 markup_result;
    231   std::string url_result;
    232   uint32 ignored;
    233   clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
    234                        &ignored, &ignored);
    235   EXPECT_PRED2(MarkupMatches, string16(), markup_result);
    236 }
    237 #endif
    238 
    239 // TODO(estade): Port the following test (decide what target we use for urls)
    240 #if !defined(OS_POSIX) || defined(OS_MACOSX)
    241 TEST_F(ClipboardTest, BookmarkTest) {
    242   string16 title(ASCIIToUTF16("The Example Company")), title_result;
    243   std::string url("http://www.example.com/"), url_result;
    244 
    245   {
    246     ScopedClipboardWriter clipboard_writer(&clipboard(),
    247                                            Clipboard::BUFFER_STANDARD);
    248     clipboard_writer.WriteBookmark(title, url);
    249   }
    250 
    251   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetUrlWFormatType(),
    252                                             Clipboard::BUFFER_STANDARD));
    253   clipboard().ReadBookmark(&title_result, &url_result);
    254   EXPECT_EQ(title, title_result);
    255   EXPECT_EQ(url, url_result);
    256 }
    257 #endif  // defined(OS_WIN)
    258 
    259 TEST_F(ClipboardTest, MultiFormatTest) {
    260   string16 text(ASCIIToUTF16("Hi!")), text_result;
    261   string16 markup(ASCIIToUTF16("<strong>Hi!</string>")), markup_result;
    262   std::string url("http://www.example.com/"), url_result;
    263   std::string ascii_text;
    264 
    265   {
    266     ScopedClipboardWriter clipboard_writer(&clipboard(),
    267                                            Clipboard::BUFFER_STANDARD);
    268     clipboard_writer.WriteHTML(markup, url);
    269     clipboard_writer.WriteText(text);
    270   }
    271 
    272   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    273                                             Clipboard::BUFFER_STANDARD));
    274   EXPECT_TRUE(clipboard().IsFormatAvailable(
    275       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
    276   EXPECT_TRUE(clipboard().IsFormatAvailable(
    277       Clipboard::GetPlainTextFormatType(), Clipboard::BUFFER_STANDARD));
    278   uint32 ignored;
    279   clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &markup_result, &url_result,
    280                        &ignored, &ignored);
    281   EXPECT_PRED2(MarkupMatches, markup, markup_result);
    282 #if defined(OS_WIN)
    283   // TODO(playmobil): It's not clear that non windows clipboards need to support
    284   // this.
    285   EXPECT_EQ(url, url_result);
    286 #endif  // defined(OS_WIN)
    287   clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
    288   EXPECT_EQ(text, text_result);
    289   clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
    290   EXPECT_EQ(UTF16ToUTF8(text), ascii_text);
    291 }
    292 
    293 TEST_F(ClipboardTest, URLTest) {
    294   string16 url(ASCIIToUTF16("http://www.google.com/"));
    295 
    296   {
    297     ScopedClipboardWriter clipboard_writer(&clipboard(),
    298                                            Clipboard::BUFFER_STANDARD);
    299     clipboard_writer.WriteURL(url);
    300   }
    301 
    302   EXPECT_TRUE(clipboard().IsFormatAvailable(
    303       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
    304   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
    305                                             Clipboard::BUFFER_STANDARD));
    306   string16 text_result;
    307   clipboard().ReadText(Clipboard::BUFFER_STANDARD, &text_result);
    308 
    309   EXPECT_EQ(text_result, url);
    310 
    311   std::string ascii_text;
    312   clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &ascii_text);
    313   EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
    314 
    315 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
    316   ascii_text.clear();
    317   clipboard().ReadAsciiText(Clipboard::BUFFER_SELECTION, &ascii_text);
    318   EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
    319 #endif
    320 }
    321 
    322 // TODO(erg): Reenable this everywhere once linux_aura learns what bitmaps are.
    323 #if !(defined(USE_AURA) && !defined(OS_CHROMEOS))
    324 TEST_F(ClipboardTest, SharedBitmapTest) {
    325   unsigned int fake_bitmap[] = {
    326     0x46155189, 0xF6A55C8D, 0x79845674, 0xFA57BD89,
    327     0x78FD46AE, 0x87C64F5A, 0x36EDC5AF, 0x4378F568,
    328     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
    329   };
    330   gfx::Size fake_bitmap_size(3, 4);
    331   uint32 bytes = sizeof(fake_bitmap);
    332 
    333   // Create shared memory region.
    334   base::SharedMemory shared_buf;
    335   ASSERT_TRUE(shared_buf.CreateAndMapAnonymous(bytes));
    336   memcpy(shared_buf.memory(), fake_bitmap, bytes);
    337   base::SharedMemoryHandle handle_to_share;
    338   base::ProcessHandle current_process = base::kNullProcessHandle;
    339 #if defined(OS_WIN)
    340   current_process = GetCurrentProcess();
    341 #endif
    342   shared_buf.ShareToProcess(current_process, &handle_to_share);
    343   ASSERT_TRUE(shared_buf.Unmap());
    344 
    345   // Setup data for clipboard().
    346   Clipboard::ObjectMapParam placeholder_param;
    347   Clipboard::ObjectMapParam size_param;
    348   const char* size_data = reinterpret_cast<const char*>(&fake_bitmap_size);
    349   for (size_t i = 0; i < sizeof(fake_bitmap_size); ++i)
    350     size_param.push_back(size_data[i]);
    351 
    352   Clipboard::ObjectMapParams params;
    353   params.push_back(placeholder_param);
    354   params.push_back(size_param);
    355 
    356   Clipboard::ObjectMap objects;
    357   objects[Clipboard::CBF_SMBITMAP] = params;
    358   Clipboard::ReplaceSharedMemHandle(&objects, handle_to_share, current_process);
    359 
    360   clipboard().WriteObjects(Clipboard::BUFFER_STANDARD,
    361                            objects);
    362 
    363   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
    364                                             Clipboard::BUFFER_STANDARD));
    365 }
    366 #endif
    367 
    368 // The following test somehow fails on GTK. The image when read back from the
    369 // clipboard has the alpha channel set to 0xFF for some reason. The other
    370 // channels stay intact. So I am turning this on only for aura.
    371 //
    372 // TODO(erg): This also crashes in linux_aura. Investigate once bitmap writing
    373 // is implemented.
    374 #if (defined(USE_AURA) && !(defined(OS_WIN) || !defined(OS_CHROMEOS))) || \
    375     defined(OS_ANDROID)
    376 TEST_F(ClipboardTest, MultipleBitmapReadWriteTest) {
    377   // Test first bitmap
    378   unsigned int fake_bitmap_1[] = {
    379     0x46155189, 0xF6A55C8D, 0x79845674, 0xFA57BD89,
    380     0x78FD46AE, 0x87C64F5A, 0x36EDC5AF, 0x4378F568,
    381     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
    382   };
    383   gfx::Size fake_bitmap_1_size(3, 4);
    384   {
    385     ScopedClipboardWriter clipboard_writer(&clipboard(),
    386                                            Clipboard::BUFFER_STANDARD);
    387     clipboard_writer.WriteBitmapFromPixels(fake_bitmap_1, fake_bitmap_1_size);
    388   }
    389   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
    390                                             Clipboard::BUFFER_STANDARD));
    391   SkBitmap image_1 = clipboard().ReadImage(Clipboard::BUFFER_STANDARD);
    392   EXPECT_EQ(fake_bitmap_1_size, gfx::Size(image_1.width(), image_1.height()));
    393   unsigned int* pixels_1 = reinterpret_cast<unsigned int*>(image_1.getPixels());
    394   for (int i = 0; i < fake_bitmap_1_size.width(); ++i) {
    395     for (int j = 0; j < fake_bitmap_1_size.height(); ++j) {
    396       int id = i * fake_bitmap_1_size.height() + j;
    397       EXPECT_EQ(fake_bitmap_1[id], pixels_1[id]);
    398     }
    399   }
    400 
    401   // Test second bitmap
    402   unsigned int fake_bitmap_2[] = {
    403     0x46155189, 0xF6A55C8D,
    404     0x79845674, 0xFA57BD89,
    405     0x78FD46AE, 0x87C64F5A,
    406     0x36EDC5AF, 0x4378F568,
    407     0x91E9F63A, 0xC31EA14F,
    408     0x69AB32DF, 0x643A3FD1,
    409     0xA6DF041D, 0x83046278,
    410   };
    411   gfx::Size fake_bitmap_2_size(7, 2);
    412   {
    413     ScopedClipboardWriter clipboard_writer(&clipboard(),
    414                                            Clipboard::BUFFER_STANDARD);
    415     clipboard_writer.WriteBitmapFromPixels(fake_bitmap_2, fake_bitmap_2_size);
    416   }
    417   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
    418                                             Clipboard::BUFFER_STANDARD));
    419   SkBitmap image_2 = clipboard().ReadImage(Clipboard::BUFFER_STANDARD);
    420   EXPECT_EQ(fake_bitmap_2_size, gfx::Size(image_2.width(), image_2.height()));
    421   unsigned int* pixels_2 = reinterpret_cast<unsigned int*>(image_2.getPixels());
    422   for (int i = 0; i < fake_bitmap_2_size.width(); ++i) {
    423     for (int j = 0; j < fake_bitmap_2_size.height(); ++j) {
    424       int id = i * fake_bitmap_2_size.height() + j;
    425       EXPECT_EQ(fake_bitmap_2[id], pixels_2[id]);
    426     }
    427   }
    428 }
    429 #endif
    430 
    431 TEST_F(ClipboardTest, DataTest) {
    432   const ui::Clipboard::FormatType kFormat =
    433       ui::Clipboard::GetFormatType("chromium/x-test-format");
    434   std::string payload("test string");
    435   Pickle write_pickle;
    436   write_pickle.WriteString(payload);
    437 
    438   {
    439     ScopedClipboardWriter clipboard_writer(&clipboard(),
    440                                            Clipboard::BUFFER_STANDARD);
    441     clipboard_writer.WritePickledData(write_pickle, kFormat);
    442   }
    443 
    444   ASSERT_TRUE(clipboard().IsFormatAvailable(
    445       kFormat, Clipboard::BUFFER_STANDARD));
    446   std::string output;
    447   clipboard().ReadData(kFormat, &output);
    448   ASSERT_FALSE(output.empty());
    449 
    450   Pickle read_pickle(output.data(), output.size());
    451   PickleIterator iter(read_pickle);
    452   std::string unpickled_string;
    453   ASSERT_TRUE(read_pickle.ReadString(&iter, &unpickled_string));
    454   EXPECT_EQ(payload, unpickled_string);
    455 }
    456 
    457 TEST_F(ClipboardTest, MultipleDataTest) {
    458   const ui::Clipboard::FormatType kFormat1 =
    459       ui::Clipboard::GetFormatType("chromium/x-test-format1");
    460   std::string payload1("test string1");
    461   Pickle write_pickle1;
    462   write_pickle1.WriteString(payload1);
    463 
    464   const ui::Clipboard::FormatType kFormat2 =
    465       ui::Clipboard::GetFormatType("chromium/x-test-format2");
    466   std::string payload2("test string2");
    467   Pickle write_pickle2;
    468   write_pickle2.WriteString(payload2);
    469 
    470   {
    471     ScopedClipboardWriter clipboard_writer(&clipboard(),
    472                                            Clipboard::BUFFER_STANDARD);
    473     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
    474     // overwrite the previous pickle for fun
    475     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
    476   }
    477 
    478   ASSERT_TRUE(clipboard().IsFormatAvailable(
    479       kFormat2, Clipboard::BUFFER_STANDARD));
    480 
    481   // Check string 2.
    482   std::string output2;
    483   clipboard().ReadData(kFormat2, &output2);
    484   ASSERT_FALSE(output2.empty());
    485 
    486   Pickle read_pickle2(output2.data(), output2.size());
    487   PickleIterator iter2(read_pickle2);
    488   std::string unpickled_string2;
    489   ASSERT_TRUE(read_pickle2.ReadString(&iter2, &unpickled_string2));
    490   EXPECT_EQ(payload2, unpickled_string2);
    491 
    492   {
    493     ScopedClipboardWriter clipboard_writer(&clipboard(),
    494                                            Clipboard::BUFFER_STANDARD);
    495     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
    496     // overwrite the previous pickle for fun
    497     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
    498   }
    499 
    500   ASSERT_TRUE(clipboard().IsFormatAvailable(
    501       kFormat1, Clipboard::BUFFER_STANDARD));
    502 
    503   // Check string 1.
    504   std::string output1;
    505   clipboard().ReadData(kFormat1, &output1);
    506   ASSERT_FALSE(output1.empty());
    507 
    508   Pickle read_pickle1(output1.data(), output1.size());
    509   PickleIterator iter1(read_pickle1);
    510   std::string unpickled_string1;
    511   ASSERT_TRUE(read_pickle1.ReadString(&iter1, &unpickled_string1));
    512   EXPECT_EQ(payload1, unpickled_string1);
    513 }
    514 
    515 #if defined(OS_WIN)  // Windows only tests.
    516 TEST_F(ClipboardTest, HyperlinkTest) {
    517   const std::string kTitle("The Example Company");
    518   const std::string kUrl("http://www.example.com/");
    519   const std::string kExpectedHtml("<a href=\"http://www.example.com/\">"
    520                                   "The Example Company</a>");
    521   std::string url_result;
    522   string16 html_result;
    523 
    524   {
    525     ScopedClipboardWriter clipboard_writer(&clipboard(),
    526                                            Clipboard::BUFFER_STANDARD);
    527     clipboard_writer.WriteHyperlink(ASCIIToUTF16(kTitle), kUrl);
    528   }
    529 
    530   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
    531                                             Clipboard::BUFFER_STANDARD));
    532   uint32 ignored;
    533   clipboard().ReadHTML(Clipboard::BUFFER_STANDARD, &html_result, &url_result,
    534                        &ignored, &ignored);
    535   EXPECT_PRED2(MarkupMatches, ASCIIToUTF16(kExpectedHtml), html_result);
    536 }
    537 
    538 TEST_F(ClipboardTest, WebSmartPasteTest) {
    539   {
    540     ScopedClipboardWriter clipboard_writer(&clipboard(),
    541                                            Clipboard::BUFFER_STANDARD);
    542     clipboard_writer.WriteWebSmartPaste();
    543   }
    544 
    545   EXPECT_TRUE(clipboard().IsFormatAvailable(
    546       Clipboard::GetWebKitSmartPasteFormatType(), Clipboard::BUFFER_STANDARD));
    547 }
    548 
    549 TEST_F(ClipboardTest, BitmapTest) {
    550   unsigned int fake_bitmap[] = {
    551     0x46155189, 0xF6A55C8D, 0x79845674, 0xFA57BD89,
    552     0x78FD46AE, 0x87C64F5A, 0x36EDC5AF, 0x4378F568,
    553     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
    554   };
    555 
    556   {
    557     ScopedClipboardWriter clipboard_writer(&clipboard(),
    558                                            Clipboard::BUFFER_STANDARD);
    559     clipboard_writer.WriteBitmapFromPixels(fake_bitmap, gfx::Size(3, 4));
    560   }
    561 
    562   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
    563                                             Clipboard::BUFFER_STANDARD));
    564 }
    565 
    566 void HtmlTestHelper(const std::string& cf_html,
    567                     const std::string& expected_html) {
    568   std::string html;
    569   ClipboardUtil::CFHtmlToHtml(cf_html, &html, NULL);
    570   EXPECT_EQ(html, expected_html);
    571 }
    572 
    573 TEST_F(ClipboardTest, HtmlTest) {
    574   // Test converting from CF_HTML format data with <!--StartFragment--> and
    575   // <!--EndFragment--> comments, like from MS Word.
    576   HtmlTestHelper("Version:1.0\r\n"
    577                  "StartHTML:0000000105\r\n"
    578                  "EndHTML:0000000199\r\n"
    579                  "StartFragment:0000000123\r\n"
    580                  "EndFragment:0000000161\r\n"
    581                  "\r\n"
    582                  "<html>\r\n"
    583                  "<body>\r\n"
    584                  "<!--StartFragment-->\r\n"
    585                  "\r\n"
    586                  "<p>Foo</p>\r\n"
    587                  "\r\n"
    588                  "<!--EndFragment-->\r\n"
    589                  "</body>\r\n"
    590                  "</html>\r\n\r\n",
    591                  "<p>Foo</p>");
    592 
    593   // Test converting from CF_HTML format data without <!--StartFragment--> and
    594   // <!--EndFragment--> comments, like from OpenOffice Writer.
    595   HtmlTestHelper("Version:1.0\r\n"
    596                  "StartHTML:0000000105\r\n"
    597                  "EndHTML:0000000151\r\n"
    598                  "StartFragment:0000000121\r\n"
    599                  "EndFragment:0000000131\r\n"
    600                  "<html>\r\n"
    601                  "<body>\r\n"
    602                  "<p>Foo</p>\r\n"
    603                  "</body>\r\n"
    604                  "</html>\r\n\r\n",
    605                  "<p>Foo</p>");
    606 }
    607 #endif  // defined(OS_WIN)
    608 
    609 // Test writing all formats we have simultaneously.
    610 TEST_F(ClipboardTest, WriteEverything) {
    611   {
    612     ScopedClipboardWriter writer(&clipboard(), Clipboard::BUFFER_STANDARD);
    613     writer.WriteText(UTF8ToUTF16("foo"));
    614     writer.WriteURL(UTF8ToUTF16("foo"));
    615     writer.WriteHTML(UTF8ToUTF16("foo"), "bar");
    616     writer.WriteBookmark(UTF8ToUTF16("foo"), "bar");
    617     writer.WriteHyperlink(ASCIIToUTF16("foo"), "bar");
    618     writer.WriteWebSmartPaste();
    619     // Left out: WriteFile, WriteFiles, WriteBitmapFromPixels, WritePickledData.
    620   }
    621 
    622   // Passes if we don't crash.
    623 }
    624 
    625 #if defined(OS_ANDROID)
    626 
    627 // Test that if another application writes some text to the pasteboard the
    628 // clipboard properly invalidates other types.
    629 TEST_F(ClipboardTest, InternalClipboardInvalidation) {
    630   const unsigned int kFakeBitmap[] = {
    631     0x46155189, 0xF6A55C8D, 0x79845674, 0xFA57BD89,
    632     0x78FD46AE, 0x87C64F5A, 0x36EDC5AF, 0x4378F568,
    633     0x91E9F63A, 0xC31EA14F, 0x69AB32DF, 0x643A3FD1,
    634   };
    635 
    636   // Write a bitmap in our clipboard().
    637   {
    638     ScopedClipboardWriter clipboard_writer(&clipboard(),
    639                                            Clipboard::BUFFER_STANDARD);
    640     clipboard_writer.WriteBitmapFromPixels(kFakeBitmap, gfx::Size(3, 4));
    641   }
    642 
    643   //
    644   // Simulate that another application copied something in the Clipboard
    645   //
    646   std::string new_value("Some text copied by some other app");
    647   using base::android::ConvertUTF8ToJavaString;
    648   using base::android::MethodID;
    649   using base::android::ScopedJavaLocalRef;
    650 
    651   JNIEnv* env = base::android::AttachCurrentThread();
    652   ASSERT_TRUE(env);
    653 
    654   jobject context = base::android::GetApplicationContext();
    655   ASSERT_TRUE(context);
    656 
    657   ScopedJavaLocalRef<jclass> context_class =
    658       base::android::GetClass(env, "android/content/Context");
    659 
    660   jmethodID get_system_service = MethodID::Get<MethodID::TYPE_INSTANCE>(
    661       env, context_class.obj(), "getSystemService",
    662       "(Ljava/lang/String;)Ljava/lang/Object;");
    663 
    664   // Retrieve the system service.
    665   ScopedJavaLocalRef<jstring> service_name = ConvertUTF8ToJavaString(
    666       env, "clipboard");
    667   ScopedJavaLocalRef<jobject> clipboard_manager(
    668       env, env->CallObjectMethod(
    669         context, get_system_service, service_name.obj()));
    670   ASSERT_TRUE(clipboard_manager.obj() && !base::android::ClearException(env));
    671 
    672   ScopedJavaLocalRef<jclass> clipboard_class =
    673       base::android::GetClass(env, "android/text/ClipboardManager");
    674   jmethodID set_text = MethodID::Get<MethodID::TYPE_INSTANCE>(
    675       env, clipboard_class.obj(), "setText", "(Ljava/lang/CharSequence;)V");
    676   ScopedJavaLocalRef<jstring> new_value_string = ConvertUTF8ToJavaString(
    677       env, new_value.c_str());
    678 
    679   // Will need to call toString as CharSequence is not always a String.
    680   env->CallVoidMethod(clipboard_manager.obj(),
    681                       set_text,
    682                       new_value_string.obj());
    683 
    684   // The bitmap that should have been available should be gone.
    685   EXPECT_FALSE(clipboard().IsFormatAvailable(Clipboard::GetBitmapFormatType(),
    686                                              Clipboard::BUFFER_STANDARD));
    687 
    688   // Make sure some text is available
    689   EXPECT_TRUE(clipboard().IsFormatAvailable(
    690       Clipboard::GetPlainTextWFormatType(), Clipboard::BUFFER_STANDARD));
    691 
    692   // Make sure the text is what we inserted while simulating the other app
    693   std::string contents;
    694   clipboard().ReadAsciiText(Clipboard::BUFFER_STANDARD, &contents);
    695   EXPECT_EQ(contents, new_value);
    696 }
    697 #endif
    698 }  // namespace ui
    699