src/ui/base/dragdrop/os_exchange_data_win_unittest.cc

   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 "base/memory/ref_counted.h"
   6 #include "base/memory/scoped_handle.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/win/scoped_hglobal.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11 #include "ui/base/clipboard/clipboard.h"
  12 #include "ui/base/dragdrop/os_exchange_data.h"
  13 #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
  14 #include "url/gurl.h"
  15
  16 namespace ui {
  17
  18 // Test getting using the IDataObject COM API
  19 TEST(OSExchangeDataWinTest, StringDataAccessViaCOM) {
  20   OSExchangeData data;
  21   std::wstring input = L"O hai googlz.";
  22   data.SetString(input);
  23   base::win::ScopedComPtr<IDataObject> com_data(
  24       OSExchangeDataProviderWin::GetIDataObject(data));
  25
  26   FORMATETC format_etc =
  27       { CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  28   EXPECT_EQ(S_OK, com_data->QueryGetData(&format_etc));
  29
  30   STGMEDIUM medium;
  31   EXPECT_EQ(S_OK, com_data->GetData(&format_etc, &medium));
  32   std::wstring output =
  33       base::win::ScopedHGlobal<wchar_t>(medium.hGlobal).get();
  34   EXPECT_EQ(input, output);
  35   ReleaseStgMedium(&medium);
  36 }
  37
  38 // Test setting using the IDataObject COM API
  39 TEST(OSExchangeDataWinTest, StringDataWritingViaCOM) {
  40   OSExchangeData data;
  41   std::wstring input = L"http://www.google.com/";
  42
  43   base::win::ScopedComPtr<IDataObject> com_data(
  44       OSExchangeDataProviderWin::GetIDataObject(data));
  45
  46   // Store data in the object using the COM SetData API.
  47   CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
  48   FORMATETC format_etc =
  49       { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  50   STGMEDIUM medium;
  51   medium.tymed = TYMED_HGLOBAL;
  52   HGLOBAL glob = GlobalAlloc(GPTR, sizeof(wchar_t) * (input.size() + 1));
  53   size_t stringsz = input.size();
  54   SIZE_T sz = GlobalSize(glob);
  55   base::win::ScopedHGlobal<wchar_t> global_lock(glob);
  56   wchar_t* buffer_handle = global_lock.get();
  57   wcscpy_s(buffer_handle, input.size() + 1, input.c_str());
  58   medium.hGlobal = glob;
  59   medium.pUnkForRelease = NULL;
  60   EXPECT_EQ(S_OK, com_data->SetData(&format_etc, &medium, TRUE));
  61
  62   // Construct a new object with the old object so that we can use our access
  63   // APIs.
  64   OSExchangeData data2(data.provider().Clone());
  65   EXPECT_TRUE(data2.HasURL(OSExchangeData::CONVERT_FILENAMES));
  66   GURL url_from_data;
  67   std::wstring title;
  68   EXPECT_TRUE(data2.GetURLAndTitle(
  69       OSExchangeData::CONVERT_FILENAMES, &url_from_data, &title));
  70   GURL reference_url(input);
  71   EXPECT_EQ(reference_url.spec(), url_from_data.spec());
  72 }
  73
  74 // Verifies SetData invoked twice with the same data clobbers existing data.
  75 TEST(OSExchangeDataWinTest, RemoveData) {
  76   OSExchangeData data;
  77   std::wstring input = L"http://www.google.com/";
  78   std::wstring input2 = L"http://www.google2.com/";
  79
  80   base::win::ScopedComPtr<IDataObject> com_data(
  81       OSExchangeDataProviderWin::GetIDataObject(data));
  82
  83   // Store data in the object using the COM SetData API.
  84   CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
  85   FORMATETC format_etc =
  86       { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  87   STGMEDIUM medium;
  88   medium.tymed = TYMED_HGLOBAL;
  89   {
  90     HGLOBAL glob = GlobalAlloc(GPTR, sizeof(wchar_t) * (input.size() + 1));
  91     size_t stringsz = input.size();
  92     SIZE_T sz = GlobalSize(glob);
  93     base::win::ScopedHGlobal<wchar_t> global_lock(glob);
  94     wchar_t* buffer_handle = global_lock.get();
  95     wcscpy_s(buffer_handle, input.size() + 1, input.c_str());
  96     medium.hGlobal = glob;
  97     medium.pUnkForRelease = NULL;
  98     EXPECT_EQ(S_OK, com_data->SetData(&format_etc, &medium, TRUE));
  99   }
 100   // This should clobber the existing data.
 101   {
 102     HGLOBAL glob = GlobalAlloc(GPTR, sizeof(wchar_t) * (input2.size() + 1));
 103     size_t stringsz = input2.size();
 104     SIZE_T sz = GlobalSize(glob);
 105     base::win::ScopedHGlobal<wchar_t> global_lock(glob);
 106     wchar_t* buffer_handle = global_lock.get();
 107     wcscpy_s(buffer_handle, input2.size() + 1, input2.c_str());
 108     medium.hGlobal = glob;
 109     medium.pUnkForRelease = NULL;
 110     EXPECT_EQ(S_OK, com_data->SetData(&format_etc, &medium, TRUE));
 111   }
 112   EXPECT_EQ(1u, static_cast<DataObjectImpl*>(com_data.get())->size());
 113
 114   // Construct a new object with the old object so that we can use our access
 115   // APIs.
 116   OSExchangeData data2(data.provider().Clone());
 117   EXPECT_TRUE(data2.HasURL(OSExchangeData::CONVERT_FILENAMES));
 118   GURL url_from_data;
 119   std::wstring title;
 120   EXPECT_TRUE(data2.GetURLAndTitle(
 121       OSExchangeData::CONVERT_FILENAMES, &url_from_data, &title));
 122   EXPECT_EQ(GURL(input2).spec(), url_from_data.spec());
 123 }
 124
 125 TEST(OSExchangeDataWinTest, URLDataAccessViaCOM) {
 126   OSExchangeData data;
 127   GURL url("http://www.google.com/");
 128   data.SetURL(url, L"");
 129   base::win::ScopedComPtr<IDataObject> com_data(
 130       OSExchangeDataProviderWin::GetIDataObject(data));
 131
 132   CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
 133   FORMATETC format_etc =
 134       { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
 135   EXPECT_EQ(S_OK, com_data->QueryGetData(&format_etc));
 136
 137   STGMEDIUM medium;
 138   EXPECT_EQ(S_OK, com_data->GetData(&format_etc, &medium));
 139   std::wstring output =
 140       base::win::ScopedHGlobal<wchar_t>(medium.hGlobal).get();
 141   EXPECT_EQ(url.spec(), base::WideToUTF8(output));
 142   ReleaseStgMedium(&medium);
 143 }
 144
 145 TEST(OSExchangeDataWinTest, MultipleFormatsViaCOM) {
 146   OSExchangeData data;
 147   std::string url_spec = "http://www.google.com/";
 148   GURL url(url_spec);
 149   std::wstring text = L"O hai googlz.";
 150   data.SetURL(url, L"Google");
 151   data.SetString(text);
 152
 153   base::win::ScopedComPtr<IDataObject> com_data(
 154       OSExchangeDataProviderWin::GetIDataObject(data));
 155
 156   CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
 157   FORMATETC url_format_etc =
 158       { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
 159   EXPECT_EQ(S_OK, com_data->QueryGetData(&url_format_etc));
 160   FORMATETC text_format_etc =
 161       { CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
 162   EXPECT_EQ(S_OK, com_data->QueryGetData(&text_format_etc));
 163
 164   STGMEDIUM medium;
 165   EXPECT_EQ(S_OK, com_data->GetData(&url_format_etc, &medium));
 166   std::wstring output_url =
 167       base::win::ScopedHGlobal<wchar_t>(medium.hGlobal).get();
 168   EXPECT_EQ(url.spec(), base::WideToUTF8(output_url));
 169   ReleaseStgMedium(&medium);
 170
 171   // The text is supposed to be the raw text of the URL, _NOT_ the value of
 172   // |text|! This is because the URL is added first and thus takes precedence!
 173   EXPECT_EQ(S_OK, com_data->GetData(&text_format_etc, &medium));
 174   std::wstring output_text =
 175       base::win::ScopedHGlobal<wchar_t>(medium.hGlobal).get();
 176   EXPECT_EQ(url_spec, base::WideToUTF8(output_text));
 177   ReleaseStgMedium(&medium);
 178 }
 179
 180 TEST(OSExchangeDataWinTest, EnumerationViaCOM) {
 181   OSExchangeData data;
 182   data.SetURL(GURL("http://www.google.com/"), L"");
 183   data.SetString(L"O hai googlz.");
 184
 185   CLIPFORMAT cfstr_file_group_descriptor =
 186       RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
 187   CLIPFORMAT text_x_moz_url = RegisterClipboardFormat(L"text/x-moz-url");
 188
 189   base::win::ScopedComPtr<IDataObject> com_data(
 190       OSExchangeDataProviderWin::GetIDataObject(data));
 191   base::win::ScopedComPtr<IEnumFORMATETC> enumerator;
 192   EXPECT_EQ(S_OK, com_data.get()->EnumFormatEtc(DATADIR_GET,
 193                                                 enumerator.Receive()));
 194
 195   // Test that we can get one item.
 196   {
 197     // Explictly don't reset the first time, to verify the creation state is
 198     // OK.
 199     ULONG retrieved = 0;
 200     FORMATETC elements_array[1];
 201     EXPECT_EQ(S_OK, enumerator->Next(1,
 202         reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
 203     EXPECT_EQ(1, retrieved);
 204     EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
 205   }
 206
 207   // Test that we can get one item with a NULL retrieved value.
 208   {
 209     EXPECT_EQ(S_OK, enumerator->Reset());
 210     FORMATETC elements_array[1];
 211     EXPECT_EQ(S_OK, enumerator->Next(1,
 212         reinterpret_cast<FORMATETC*>(&elements_array), NULL));
 213     EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
 214   }
 215
 216   // Test that we can get two items.
 217   {
 218     EXPECT_EQ(S_OK, enumerator->Reset());
 219     ULONG retrieved = 0;
 220     FORMATETC elements_array[2];
 221     EXPECT_EQ(S_OK, enumerator->Next(2,
 222         reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
 223     EXPECT_EQ(2, retrieved);
 224     EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
 225     EXPECT_EQ(cfstr_file_group_descriptor, elements_array[1].cfFormat);
 226   }
 227
 228   // Test that we can skip the first item.
 229   {
 230     EXPECT_EQ(S_OK, enumerator->Reset());
 231     EXPECT_EQ(S_OK, enumerator->Skip(1));
 232     ULONG retrieved = 0;
 233     FORMATETC elements_array[1];
 234     EXPECT_EQ(S_OK, enumerator->Next(1,
 235         reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
 236     EXPECT_EQ(1, retrieved);
 237     EXPECT_EQ(cfstr_file_group_descriptor, elements_array[0].cfFormat);
 238   }
 239
 240   // Test that we can skip the first item, and create a clone that matches in
 241   // this state, and modify the original without affecting the clone.
 242   {
 243     EXPECT_EQ(S_OK, enumerator->Reset());
 244     EXPECT_EQ(S_OK, enumerator->Skip(1));
 245     base::win::ScopedComPtr<IEnumFORMATETC> cloned_enumerator;
 246     EXPECT_EQ(S_OK, enumerator.get()->Clone(cloned_enumerator.Receive()));
 247     EXPECT_EQ(S_OK, enumerator.get()->Reset());
 248
 249     {
 250       ULONG retrieved = 0;
 251       FORMATETC elements_array[1];
 252       EXPECT_EQ(S_OK, cloned_enumerator->Next(1,
 253           reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
 254       EXPECT_EQ(1, retrieved);
 255       EXPECT_EQ(cfstr_file_group_descriptor, elements_array[0].cfFormat);
 256     }
 257
 258     {
 259       ULONG retrieved = 0;
 260       FORMATETC elements_array[1];
 261       EXPECT_EQ(S_OK, enumerator->Next(1,
 262           reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
 263       EXPECT_EQ(1, retrieved);
 264       EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
 265     }
 266   }
 267 }
 268
 269 TEST(OSExchangeDataWinTest, TestURLExchangeFormatsViaCOM) {
 270   OSExchangeData data;
 271   std::string url_spec = "http://www.google.com/";
 272   GURL url(url_spec);
 273   std::wstring url_title = L"www.google.com";
 274   data.SetURL(url, url_title);
 275
 276   // File contents access via COM
 277   base::win::ScopedComPtr<IDataObject> com_data(
 278       OSExchangeDataProviderWin::GetIDataObject(data));
 279   {
 280     CLIPFORMAT cfstr_file_contents =
 281         RegisterClipboardFormat(CFSTR_FILECONTENTS);
 282     FORMATETC format_etc =
 283         { cfstr_file_contents, NULL, DVASPECT_CONTENT, 0, TYMED_HGLOBAL };
 284     EXPECT_EQ(S_OK, com_data->QueryGetData(&format_etc));
 285
 286     STGMEDIUM medium;
 287     EXPECT_EQ(S_OK, com_data->GetData(&format_etc, &medium));
 288     base::win::ScopedHGlobal<char> glob(medium.hGlobal);
 289     std::string output(glob.get(), glob.Size());
 290     std::string file_contents = "[InternetShortcut]\r\nURL=";
 291     file_contents += url_spec;
 292     file_contents += "\r\n";
 293     EXPECT_EQ(file_contents, output);
 294     ReleaseStgMedium(&medium);
 295   }
 296 }
 297
 298 TEST(OSExchangeDataWinTest, FileContents) {
 299   OSExchangeData data;
 300   std::string file_contents("data\0with\0nulls", 15);
 301   data.SetFileContents(base::FilePath(L"filename.txt"), file_contents);
 302
 303   OSExchangeData copy(data.provider().Clone());
 304   base::FilePath filename;
 305   std::string read_contents;
 306   EXPECT_TRUE(copy.GetFileContents(&filename, &read_contents));
 307   EXPECT_EQ(L"filename.txt", filename.value());
 308   EXPECT_EQ(file_contents, read_contents);
 309 }
 310
 311 TEST(OSExchangeDataWinTest, CFHtml) {
 312   OSExchangeData data;
 313   GURL url("http://www.google.com/");
 314   std::wstring html(
 315       L"<HTML>\n<BODY>\n"
 316       L"<b>bold.</b> <i><b>This is bold italic.</b></i>\n"
 317       L"</BODY>\n</HTML>");
 318   data.SetHtml(html, url);
 319
 320   // Check the CF_HTML too.
 321   std::string expected_cf_html(
 322       "Version:0.9\r\nStartHTML:0000000139\r\nEndHTML:0000000288\r\n"
 323       "StartFragment:0000000175\r\nEndFragment:0000000252\r\n"
 324       "SourceURL:http://www.google.com/\r\n<html>\r\n<body>\r\n"
 325       "<!--StartFragment-->");
 326   expected_cf_html += base::WideToUTF8(html);
 327   expected_cf_html.append("<!--EndFragment-->\r\n</body>\r\n</html>");
 328
 329   FORMATETC format = Clipboard::GetHtmlFormatType().ToFormatEtc();
 330   STGMEDIUM medium;
 331   IDataObject* data_object = OSExchangeDataProviderWin::GetIDataObject(data);
 332   EXPECT_EQ(S_OK, data_object->GetData(&format, &medium));
 333   base::win::ScopedHGlobal<char> glob(medium.hGlobal);
 334   std::string output(glob.get(), glob.Size());
 335   EXPECT_EQ(expected_cf_html, output);
 336   ReleaseStgMedium(&medium);
 337 }
 338
 339 TEST(OSExchangeDataWinTest, SetURLWithMaxPath) {
 340   OSExchangeData data;
 341   std::wstring long_title(L'a', MAX_PATH + 1);
 342   data.SetURL(GURL("http://google.com"), long_title);
 343 }
 344
 345 TEST(OSExchangeDataWinTest, ProvideURLForPlainTextURL) {
 346   OSExchangeData data;
 347   data.SetString(L"http://google.com");
 348
 349   OSExchangeData data2(data.provider().Clone());
 350   ASSERT_TRUE(data2.HasURL(OSExchangeData::CONVERT_FILENAMES));
 351   GURL read_url;
 352   std::wstring title;
 353   EXPECT_TRUE(data2.GetURLAndTitle(
 354       OSExchangeData::CONVERT_FILENAMES, &read_url, &title));
 355   EXPECT_EQ(GURL("http://google.com"), read_url);
 356 }
 357
 358 }  // namespace ui