| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
