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