os_exchange_data_win_unittest.cc 40 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046
  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. #include "ui/base/dragdrop/os_exchange_data.h"
  5. #include <objbase.h>
  6. #include <memory>
  7. #include "base/bind.h"
  8. #include "base/callback.h"
  9. #include "base/containers/contains.h"
  10. #include "base/files/file_util.h"
  11. #include "base/memory/ref_counted.h"
  12. #include "base/sequence_checker.h"
  13. #include "base/strings/string_util.h"
  14. #include "base/strings/utf_string_conversions.h"
  15. #include "base/test/task_environment.h"
  16. #include "base/win/scoped_hglobal.h"
  17. #include "testing/gmock/include/gmock/gmock.h"
  18. #include "testing/gtest/include/gtest/gtest.h"
  19. #include "testing/platform_test.h"
  20. #include "ui/base/clipboard/clipboard_format_type.h"
  21. #include "ui/base/clipboard/file_info.h"
  22. #include "ui/base/dragdrop/os_exchange_data_provider_win.h"
  23. #include "url/gurl.h"
  24. namespace ui {
  25. namespace {
  26. const std::vector<DWORD> kStorageMediaTypesForVirtualFiles = {
  27. TYMED_ISTORAGE,
  28. TYMED_ISTREAM,
  29. TYMED_HGLOBAL,
  30. };
  31. class RefCountMockStream : public IStream {
  32. public:
  33. RefCountMockStream() = default;
  34. ~RefCountMockStream() = default;
  35. ULONG GetRefCount() const {
  36. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  37. return ref_count_;
  38. }
  39. // Overridden from IUnknown:
  40. IFACEMETHODIMP QueryInterface(REFIID iid, void** object) override {
  41. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  42. if (iid == IID_IUnknown || iid == IID_ISequentialStream ||
  43. iid == IID_IStream) {
  44. *object = static_cast<IStream*>(this);
  45. AddRef();
  46. return S_OK;
  47. }
  48. *object = nullptr;
  49. return E_NOINTERFACE;
  50. }
  51. IFACEMETHODIMP_(ULONG) AddRef(void) override {
  52. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  53. return ++ref_count_;
  54. }
  55. IFACEMETHODIMP_(ULONG) Release(void) override {
  56. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  57. EXPECT_GT(ref_count_, 0u);
  58. return --ref_count_;
  59. }
  60. // Overridden from ISequentialStream:
  61. MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
  62. Read,
  63. HRESULT(void* pv, ULONG cb, ULONG* pcbRead));
  64. MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
  65. Write,
  66. HRESULT(void const* pv, ULONG cb, ULONG* pcbW));
  67. // Overridden from IStream:
  68. MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
  69. SetSize,
  70. HRESULT(ULARGE_INTEGER));
  71. MOCK_METHOD4_WITH_CALLTYPE(
  72. STDMETHODCALLTYPE,
  73. CopyTo,
  74. HRESULT(IStream*, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*));
  75. MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Commit, HRESULT(DWORD));
  76. MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, Revert, HRESULT());
  77. MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
  78. LockRegion,
  79. HRESULT(ULARGE_INTEGER, ULARGE_INTEGER, DWORD));
  80. MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
  81. UnlockRegion,
  82. HRESULT(ULARGE_INTEGER, ULARGE_INTEGER, DWORD));
  83. MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Clone, HRESULT(IStream**));
  84. MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
  85. Seek,
  86. HRESULT(LARGE_INTEGER liDistanceToMove,
  87. DWORD dwOrigin,
  88. ULARGE_INTEGER* lpNewFilePointer));
  89. MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
  90. Stat,
  91. HRESULT(STATSTG* pStatstg, DWORD grfStatFlag));
  92. private:
  93. ULONG ref_count_ = 0u;
  94. SEQUENCE_CHECKER(sequence_checker_);
  95. };
  96. } // namespace
  97. class OSExchangeDataWinTest : public ::testing::Test {
  98. public:
  99. OSExchangeDataWinTest()
  100. : task_environment_(base::test::TaskEnvironment::MainThreadType::UI) {}
  101. void OnGotVirtualFilesAsTempFiles(
  102. const std::vector<std::pair<base::FilePath, base::FilePath>>&
  103. filepaths_and_names) {
  104. // Clear any previous results and cache a vector of FileInfo objects for
  105. // verification.
  106. retrieved_virtual_files_.clear();
  107. for (const auto& filepath_and_name : filepaths_and_names) {
  108. retrieved_virtual_files_.push_back(
  109. FileInfo(filepath_and_name.first, filepath_and_name.second));
  110. }
  111. }
  112. protected:
  113. std::vector<FileInfo> retrieved_virtual_files_;
  114. base::test::TaskEnvironment task_environment_;
  115. };
  116. // Test getting using the IDataObject COM API
  117. TEST_F(OSExchangeDataWinTest, StringDataAccessViaCOM) {
  118. OSExchangeData data;
  119. std::wstring input = L"O hai googlz.";
  120. data.SetString(base::AsString16(input));
  121. Microsoft::WRL::ComPtr<IDataObject> com_data(
  122. OSExchangeDataProviderWin::GetIDataObject(data));
  123. FORMATETC format_etc =
  124. { CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  125. EXPECT_EQ(S_OK, com_data->QueryGetData(&format_etc));
  126. STGMEDIUM medium;
  127. EXPECT_EQ(S_OK, com_data->GetData(&format_etc, &medium));
  128. std::wstring output =
  129. base::win::ScopedHGlobal<wchar_t*>(medium.hGlobal).get();
  130. EXPECT_EQ(input, output);
  131. ReleaseStgMedium(&medium);
  132. }
  133. // Test setting using the IDataObject COM API
  134. TEST_F(OSExchangeDataWinTest, StringDataWritingViaCOM) {
  135. OSExchangeData data;
  136. std::wstring input = L"http://www.google.com/";
  137. Microsoft::WRL::ComPtr<IDataObject> com_data(
  138. OSExchangeDataProviderWin::GetIDataObject(data));
  139. // Store data in the object using the COM SetData API.
  140. CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
  141. FORMATETC format_etc =
  142. { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  143. STGMEDIUM medium;
  144. medium.tymed = TYMED_HGLOBAL;
  145. HGLOBAL glob = GlobalAlloc(GPTR, sizeof(wchar_t) * (input.size() + 1));
  146. base::win::ScopedHGlobal<wchar_t*> global_lock(glob);
  147. wchar_t* buffer_handle = global_lock.get();
  148. wcscpy_s(buffer_handle, input.size() + 1, input.c_str());
  149. medium.hGlobal = glob;
  150. medium.pUnkForRelease = NULL;
  151. EXPECT_EQ(S_OK, com_data->SetData(&format_etc, &medium, TRUE));
  152. // Construct a new object with the old object so that we can use our access
  153. // APIs.
  154. OSExchangeData data2(data.provider().Clone());
  155. EXPECT_TRUE(data2.HasURL(FilenameToURLPolicy::CONVERT_FILENAMES));
  156. GURL url_from_data;
  157. std::u16string title;
  158. EXPECT_TRUE(data2.GetURLAndTitle(FilenameToURLPolicy::CONVERT_FILENAMES,
  159. &url_from_data, &title));
  160. GURL reference_url(base::AsStringPiece16(input));
  161. EXPECT_EQ(reference_url.spec(), url_from_data.spec());
  162. }
  163. // Verifies SetData invoked twice with the same data clobbers existing data.
  164. TEST_F(OSExchangeDataWinTest, RemoveData) {
  165. OSExchangeData data;
  166. std::wstring input = L"http://www.google.com/";
  167. std::wstring input2 = L"http://www.google2.com/";
  168. Microsoft::WRL::ComPtr<IDataObject> com_data(
  169. OSExchangeDataProviderWin::GetIDataObject(data));
  170. // Store data in the object using the COM SetData API.
  171. CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
  172. FORMATETC format_etc =
  173. { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  174. STGMEDIUM medium;
  175. medium.tymed = TYMED_HGLOBAL;
  176. {
  177. HGLOBAL glob = GlobalAlloc(GPTR, sizeof(wchar_t) * (input.size() + 1));
  178. base::win::ScopedHGlobal<wchar_t*> global_lock(glob);
  179. wchar_t* buffer_handle = global_lock.get();
  180. wcscpy_s(buffer_handle, input.size() + 1, input.c_str());
  181. medium.hGlobal = glob;
  182. medium.pUnkForRelease = NULL;
  183. EXPECT_EQ(S_OK, com_data->SetData(&format_etc, &medium, TRUE));
  184. }
  185. // This should clobber the existing data.
  186. {
  187. HGLOBAL glob = GlobalAlloc(GPTR, sizeof(wchar_t) * (input2.size() + 1));
  188. base::win::ScopedHGlobal<wchar_t*> global_lock(glob);
  189. wchar_t* buffer_handle = global_lock.get();
  190. wcscpy_s(buffer_handle, input2.size() + 1, input2.c_str());
  191. medium.hGlobal = glob;
  192. medium.pUnkForRelease = NULL;
  193. EXPECT_EQ(S_OK, com_data->SetData(&format_etc, &medium, TRUE));
  194. }
  195. EXPECT_EQ(1u, static_cast<DataObjectImpl*>(com_data.Get())->size());
  196. // Construct a new object with the old object so that we can use our access
  197. // APIs.
  198. OSExchangeData data2(data.provider().Clone());
  199. EXPECT_TRUE(data2.HasURL(FilenameToURLPolicy::CONVERT_FILENAMES));
  200. GURL url_from_data;
  201. std::u16string title;
  202. EXPECT_TRUE(data2.GetURLAndTitle(FilenameToURLPolicy::CONVERT_FILENAMES,
  203. &url_from_data, &title));
  204. EXPECT_EQ(GURL(base::AsStringPiece16(input2)).spec(), url_from_data.spec());
  205. }
  206. TEST_F(OSExchangeDataWinTest, URLDataAccessViaCOM) {
  207. OSExchangeData data;
  208. GURL url("http://www.google.com/");
  209. data.SetURL(url, std::u16string());
  210. Microsoft::WRL::ComPtr<IDataObject> com_data(
  211. OSExchangeDataProviderWin::GetIDataObject(data));
  212. CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
  213. FORMATETC format_etc =
  214. { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  215. EXPECT_EQ(S_OK, com_data->QueryGetData(&format_etc));
  216. STGMEDIUM medium;
  217. EXPECT_EQ(S_OK, com_data->GetData(&format_etc, &medium));
  218. std::wstring output =
  219. base::win::ScopedHGlobal<wchar_t*>(medium.hGlobal).get();
  220. EXPECT_EQ(url.spec(), base::WideToUTF8(output));
  221. ReleaseStgMedium(&medium);
  222. }
  223. TEST_F(OSExchangeDataWinTest, MultipleFormatsViaCOM) {
  224. OSExchangeData data;
  225. std::string url_spec = "http://www.google.com/";
  226. GURL url(url_spec);
  227. std::u16string text = u"O hai googlz.";
  228. data.SetURL(url, u"Google");
  229. data.SetString(text);
  230. Microsoft::WRL::ComPtr<IDataObject> com_data(
  231. OSExchangeDataProviderWin::GetIDataObject(data));
  232. CLIPFORMAT cfstr_ineturl = RegisterClipboardFormat(CFSTR_INETURL);
  233. FORMATETC url_format_etc =
  234. { cfstr_ineturl, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  235. EXPECT_EQ(S_OK, com_data->QueryGetData(&url_format_etc));
  236. FORMATETC text_format_etc =
  237. { CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  238. EXPECT_EQ(S_OK, com_data->QueryGetData(&text_format_etc));
  239. STGMEDIUM medium;
  240. EXPECT_EQ(S_OK, com_data->GetData(&url_format_etc, &medium));
  241. std::wstring output_url =
  242. base::win::ScopedHGlobal<wchar_t*>(medium.hGlobal).get();
  243. EXPECT_EQ(url.spec(), base::WideToUTF8(output_url));
  244. ReleaseStgMedium(&medium);
  245. // The text is supposed to be the raw text of the URL, _NOT_ the value of
  246. // |text|! This is because the URL is added first and thus takes precedence!
  247. EXPECT_EQ(S_OK, com_data->GetData(&text_format_etc, &medium));
  248. std::wstring output_text =
  249. base::win::ScopedHGlobal<wchar_t*>(medium.hGlobal).get();
  250. EXPECT_EQ(url_spec, base::WideToUTF8(output_text));
  251. ReleaseStgMedium(&medium);
  252. }
  253. TEST_F(OSExchangeDataWinTest, EnumerationViaCOM) {
  254. OSExchangeData data;
  255. data.SetURL(GURL("http://www.google.com/"), std::u16string());
  256. data.SetString(u"O hai googlz.");
  257. CLIPFORMAT cfstr_file_group_descriptor =
  258. RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
  259. CLIPFORMAT text_x_moz_url = RegisterClipboardFormat(L"text/x-moz-url");
  260. Microsoft::WRL::ComPtr<IDataObject> com_data(
  261. OSExchangeDataProviderWin::GetIDataObject(data));
  262. Microsoft::WRL::ComPtr<IEnumFORMATETC> enumerator;
  263. EXPECT_EQ(S_OK, com_data.Get()->EnumFormatEtc(DATADIR_GET, &enumerator));
  264. // Test that we can get one item.
  265. {
  266. // Explictly don't reset the first time, to verify the creation state is
  267. // OK.
  268. ULONG retrieved = 0;
  269. FORMATETC elements_array[1];
  270. EXPECT_EQ(S_OK, enumerator->Next(1,
  271. reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
  272. EXPECT_EQ(1u, retrieved);
  273. EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
  274. }
  275. // Test that we can get one item with a NULL retrieved value.
  276. {
  277. EXPECT_EQ(S_OK, enumerator->Reset());
  278. FORMATETC elements_array[1];
  279. EXPECT_EQ(S_OK, enumerator->Next(1,
  280. reinterpret_cast<FORMATETC*>(&elements_array), NULL));
  281. EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
  282. }
  283. // Test that we can get two items.
  284. {
  285. EXPECT_EQ(S_OK, enumerator->Reset());
  286. ULONG retrieved = 0;
  287. FORMATETC elements_array[2];
  288. EXPECT_EQ(S_OK, enumerator->Next(2,
  289. reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
  290. EXPECT_EQ(2u, retrieved);
  291. EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
  292. EXPECT_EQ(cfstr_file_group_descriptor, elements_array[1].cfFormat);
  293. }
  294. // Test that we can skip the first item.
  295. {
  296. EXPECT_EQ(S_OK, enumerator->Reset());
  297. EXPECT_EQ(S_OK, enumerator->Skip(1));
  298. ULONG retrieved = 0;
  299. FORMATETC elements_array[1];
  300. EXPECT_EQ(S_OK, enumerator->Next(1,
  301. reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
  302. EXPECT_EQ(1u, retrieved);
  303. EXPECT_EQ(cfstr_file_group_descriptor, elements_array[0].cfFormat);
  304. }
  305. // Test that we can skip the first item, and create a clone that matches in
  306. // this state, and modify the original without affecting the clone.
  307. {
  308. EXPECT_EQ(S_OK, enumerator->Reset());
  309. EXPECT_EQ(S_OK, enumerator->Skip(1));
  310. Microsoft::WRL::ComPtr<IEnumFORMATETC> cloned_enumerator;
  311. EXPECT_EQ(S_OK, enumerator.Get()->Clone(&cloned_enumerator));
  312. EXPECT_EQ(S_OK, enumerator.Get()->Reset());
  313. {
  314. ULONG retrieved = 0;
  315. FORMATETC elements_array[1];
  316. EXPECT_EQ(S_OK, cloned_enumerator->Next(1,
  317. reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
  318. EXPECT_EQ(1u, retrieved);
  319. EXPECT_EQ(cfstr_file_group_descriptor, elements_array[0].cfFormat);
  320. }
  321. {
  322. ULONG retrieved = 0;
  323. FORMATETC elements_array[1];
  324. EXPECT_EQ(S_OK, enumerator->Next(1,
  325. reinterpret_cast<FORMATETC*>(&elements_array), &retrieved));
  326. EXPECT_EQ(1u, retrieved);
  327. EXPECT_EQ(text_x_moz_url, elements_array[0].cfFormat);
  328. }
  329. }
  330. }
  331. TEST_F(OSExchangeDataWinTest, TestURLExchangeFormatsViaCOM) {
  332. OSExchangeData data;
  333. std::string url_spec = "http://www.google.com/";
  334. GURL url(url_spec);
  335. std::u16string url_title = u"www.google.com";
  336. data.SetURL(url, url_title);
  337. // File contents access via COM
  338. Microsoft::WRL::ComPtr<IDataObject> com_data(
  339. OSExchangeDataProviderWin::GetIDataObject(data));
  340. {
  341. CLIPFORMAT cfstr_file_contents =
  342. RegisterClipboardFormat(CFSTR_FILECONTENTS);
  343. // format_etc.lindex value 0 used for file drop.
  344. FORMATETC format_etc = {cfstr_file_contents, nullptr, DVASPECT_CONTENT, 0,
  345. TYMED_HGLOBAL};
  346. EXPECT_EQ(S_OK, com_data->QueryGetData(&format_etc));
  347. STGMEDIUM medium;
  348. EXPECT_EQ(S_OK, com_data->GetData(&format_etc, &medium));
  349. base::win::ScopedHGlobal<char*> glob(medium.hGlobal);
  350. std::string output(glob.get(), glob.Size());
  351. std::string file_contents = "[InternetShortcut]\r\nURL=";
  352. file_contents += url_spec;
  353. file_contents += "\r\n";
  354. EXPECT_EQ(file_contents, output);
  355. ReleaseStgMedium(&medium);
  356. }
  357. }
  358. TEST_F(OSExchangeDataWinTest, FileContents) {
  359. OSExchangeData data;
  360. std::string file_contents("data\0with\0nulls", 15);
  361. data.SetFileContents(base::FilePath(L"filename.txt"), file_contents);
  362. OSExchangeData copy(data.provider().Clone());
  363. base::FilePath filename;
  364. std::string read_contents;
  365. EXPECT_TRUE(copy.GetFileContents(&filename, &read_contents));
  366. EXPECT_EQ(L"filename.txt", filename.value());
  367. EXPECT_EQ(file_contents, read_contents);
  368. }
  369. TEST_F(OSExchangeDataWinTest, VirtualFiles) {
  370. const base::FilePath kPathPlaceholder(FILE_PATH_LITERAL("temp.tmp"));
  371. const std::vector<std::pair<base::FilePath, std::string>>
  372. kTestFilenamesAndContents = {
  373. {base::FilePath(FILE_PATH_LITERAL("filename.txt")),
  374. std::string("just some data")},
  375. {base::FilePath(FILE_PATH_LITERAL("another filename.txt")),
  376. std::string("just some data\0with\0nulls", 25)},
  377. {base::FilePath(FILE_PATH_LITERAL("and another filename.txt")),
  378. std::string("just some more data")},
  379. };
  380. for (const auto& tymed : kStorageMediaTypesForVirtualFiles) {
  381. OSExchangeData data;
  382. data.provider().SetVirtualFileContentsForTesting(kTestFilenamesAndContents,
  383. tymed);
  384. OSExchangeData copy(data.provider().Clone());
  385. std::vector<FileInfo> file_infos;
  386. EXPECT_TRUE(copy.GetVirtualFilenames(&file_infos));
  387. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  388. for (size_t i = 0; i < file_infos.size(); i++) {
  389. EXPECT_EQ(kTestFilenamesAndContents[i].first, file_infos[i].display_name);
  390. EXPECT_EQ(kPathPlaceholder, file_infos[i].path);
  391. }
  392. base::FilePath temp_dir;
  393. EXPECT_TRUE(base::GetTempDir(&temp_dir));
  394. // Callback for GetVirtualFilesAsTempFiles is executed when all virtual
  395. // files are backed by temp files.
  396. auto callback =
  397. base::BindOnce(&OSExchangeDataWinTest::OnGotVirtualFilesAsTempFiles,
  398. base::Unretained(this));
  399. EXPECT_TRUE(copy.GetVirtualFilesAsTempFiles(std::move(callback)));
  400. // RunUntilIdle assures all async tasks are run.
  401. task_environment_.RunUntilIdle();
  402. EXPECT_EQ(kTestFilenamesAndContents.size(),
  403. retrieved_virtual_files_.size());
  404. for (size_t i = 0; i < retrieved_virtual_files_.size(); i++) {
  405. EXPECT_EQ(kTestFilenamesAndContents[i].first,
  406. retrieved_virtual_files_[i].display_name);
  407. // Check if the temp files that back the virtual files are actually
  408. // created in the temp directory. Need to compare long file paths here
  409. // because GetTempDir can return a short ("8.3") path if the test is run
  410. // under a username that is too long.
  411. EXPECT_EQ(
  412. base::MakeLongFilePath(temp_dir),
  413. base::MakeLongFilePath(retrieved_virtual_files_[i].path.DirName()));
  414. EXPECT_EQ(kTestFilenamesAndContents[i].first.Extension(),
  415. retrieved_virtual_files_[i].path.Extension());
  416. std::string read_contents;
  417. EXPECT_TRUE(base::ReadFileToString(retrieved_virtual_files_[i].path,
  418. &read_contents));
  419. if (tymed != TYMED_ISTORAGE) {
  420. EXPECT_EQ(kTestFilenamesAndContents[i].second, read_contents);
  421. } else {
  422. // IStorage uses compound files, so temp files won't be flat text files.
  423. // Just make sure the original contents appears in the compound files.
  424. EXPECT_TRUE(
  425. base::Contains(read_contents, kTestFilenamesAndContents[i].second));
  426. }
  427. }
  428. }
  429. }
  430. TEST_F(OSExchangeDataWinTest, VirtualFilesRealFilesPreferred) {
  431. // Verify that no virtual files retrieved if there is real file data.
  432. const std::vector<FileInfo> kTestFilenames = {
  433. {base::FilePath(FILE_PATH_LITERAL("C:\\tmp\\test_file1")),
  434. base::FilePath()},
  435. {base::FilePath(FILE_PATH_LITERAL("C:\\tmp\\test_file2")),
  436. base::FilePath()},
  437. };
  438. const std::vector<std::pair<base::FilePath, std::string>>
  439. kTestFilenamesAndContents = {
  440. {base::FilePath(FILE_PATH_LITERAL("filename.txt")),
  441. std::string("just some data")},
  442. {base::FilePath(FILE_PATH_LITERAL("another filename.txt")),
  443. std::string("just some data\0with\0nulls", 25)},
  444. {base::FilePath(FILE_PATH_LITERAL("and another filename.txt")),
  445. std::string("just some more data")},
  446. };
  447. for (const auto& tymed : kStorageMediaTypesForVirtualFiles) {
  448. OSExchangeData data;
  449. data.SetFilenames(kTestFilenames);
  450. data.provider().SetVirtualFileContentsForTesting(kTestFilenamesAndContents,
  451. tymed);
  452. OSExchangeData copy(data.provider().Clone());
  453. std::vector<FileInfo> real_filenames;
  454. EXPECT_TRUE(copy.GetFilenames(&real_filenames));
  455. EXPECT_EQ(kTestFilenames.size(), real_filenames.size());
  456. EXPECT_EQ(kTestFilenames, real_filenames);
  457. std::vector<FileInfo> file_infos;
  458. EXPECT_FALSE(copy.GetVirtualFilenames(&file_infos));
  459. EXPECT_EQ(static_cast<size_t>(0), file_infos.size());
  460. // Callback for GetVirtualFilesAsTempFiles is executed when all virtual
  461. // files are backed by temp files.
  462. auto callback =
  463. base::BindOnce(&OSExchangeDataWinTest::OnGotVirtualFilesAsTempFiles,
  464. base::Unretained(this));
  465. EXPECT_FALSE(copy.GetVirtualFilesAsTempFiles(std::move(callback)));
  466. // RunUntilIdle assures all async tasks are run.
  467. task_environment_.RunUntilIdle();
  468. EXPECT_EQ(static_cast<size_t>(0), retrieved_virtual_files_.size());
  469. }
  470. }
  471. TEST_F(OSExchangeDataWinTest, VirtualFilesDuplicateNames) {
  472. const std::vector<std::pair<base::FilePath, std::string>>
  473. kTestFilenamesAndContents = {
  474. {base::FilePath(FILE_PATH_LITERAL("A (1) (2).txt")),
  475. std::string("just some data")},
  476. {base::FilePath(FILE_PATH_LITERAL("A.txt")),
  477. std::string("just some more data")},
  478. {base::FilePath(FILE_PATH_LITERAL("A (1).txt")),
  479. std::string("just some more more data")},
  480. {base::FilePath(FILE_PATH_LITERAL("A.txt")),
  481. std::string("just some more more more data")},
  482. };
  483. for (const auto& tymed : kStorageMediaTypesForVirtualFiles) {
  484. OSExchangeData data;
  485. data.provider().SetVirtualFileContentsForTesting(kTestFilenamesAndContents,
  486. tymed);
  487. OSExchangeData copy(data.provider().Clone());
  488. std::vector<FileInfo> file_infos;
  489. EXPECT_TRUE(copy.GetVirtualFilenames(&file_infos));
  490. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  491. for (size_t i = 0; i < file_infos.size(); i++) {
  492. // Check that display name is unique.
  493. for (size_t j = 0; j < i; j++) {
  494. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  495. file_infos[j].display_name.value(),
  496. file_infos[i].display_name.value()));
  497. }
  498. }
  499. base::FilePath temp_dir;
  500. EXPECT_TRUE(base::GetTempDir(&temp_dir));
  501. // Callback for GetVirtualFilesAsTempFiles is executed when all virtual
  502. // files are backed by temp files.
  503. auto callback =
  504. base::BindOnce(&OSExchangeDataWinTest::OnGotVirtualFilesAsTempFiles,
  505. base::Unretained(this));
  506. EXPECT_TRUE(copy.GetVirtualFilesAsTempFiles(std::move(callback)));
  507. // RunUntilIdle assures all async tasks are run.
  508. task_environment_.RunUntilIdle();
  509. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  510. for (size_t i = 0; i < retrieved_virtual_files_.size(); i++) {
  511. // Check that display name is unique.
  512. for (size_t j = 0; j < i; j++) {
  513. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  514. retrieved_virtual_files_[j].display_name.value(),
  515. retrieved_virtual_files_[i].display_name.value()));
  516. }
  517. // Check that temp file path is unique.
  518. for (size_t j = 0; j < i; j++) {
  519. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  520. retrieved_virtual_files_[j].path.value(),
  521. retrieved_virtual_files_[i].path.value()));
  522. }
  523. // Check if the temp files that back the virtual files are actually
  524. // created in the temp directory. Need to compare long file paths here
  525. // because GetTempDir can return a short ("8.3") path if the test is run
  526. // under a username that is too long.
  527. EXPECT_EQ(
  528. base::MakeLongFilePath(temp_dir),
  529. base::MakeLongFilePath(retrieved_virtual_files_[i].path.DirName()));
  530. EXPECT_EQ(kTestFilenamesAndContents[i].first.Extension(),
  531. retrieved_virtual_files_[i].path.Extension());
  532. std::string read_contents;
  533. EXPECT_TRUE(base::ReadFileToString(retrieved_virtual_files_[i].path,
  534. &read_contents));
  535. if (tymed != TYMED_ISTORAGE) {
  536. EXPECT_EQ(kTestFilenamesAndContents[i].second, read_contents);
  537. } else {
  538. // IStorage uses compound files, so temp files won't be flat text files.
  539. // Just make sure the original contents appears in the compound files.
  540. EXPECT_TRUE(
  541. base::Contains(read_contents, kTestFilenamesAndContents[i].second));
  542. }
  543. }
  544. }
  545. } // namespace ui
  546. TEST_F(OSExchangeDataWinTest, VirtualFilesDuplicateNamesCaseInsensitivity) {
  547. const std::vector<std::pair<base::FilePath, std::string>>
  548. kTestFilenamesAndContents = {
  549. {base::FilePath(FILE_PATH_LITERAL("a.txt")),
  550. std::string("just some data")},
  551. {base::FilePath(FILE_PATH_LITERAL("B.txt")),
  552. std::string("just some more data")},
  553. {base::FilePath(FILE_PATH_LITERAL("A.txt")),
  554. std::string("just some more more data")},
  555. };
  556. for (const auto& tymed : kStorageMediaTypesForVirtualFiles) {
  557. OSExchangeData data;
  558. data.provider().SetVirtualFileContentsForTesting(kTestFilenamesAndContents,
  559. tymed);
  560. OSExchangeData copy(data.provider().Clone());
  561. std::vector<FileInfo> file_infos;
  562. EXPECT_TRUE(copy.GetVirtualFilenames(&file_infos));
  563. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  564. for (size_t i = 0; i < file_infos.size(); i++) {
  565. // Check that display name is unique.
  566. for (size_t j = 0; j < i; j++) {
  567. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  568. file_infos[j].display_name.value(),
  569. file_infos[i].display_name.value()));
  570. }
  571. }
  572. base::FilePath temp_dir;
  573. EXPECT_TRUE(base::GetTempDir(&temp_dir));
  574. // Callback for GetVirtualFilesAsTempFiles is executed when all virtual
  575. // files are backed by temp files.
  576. auto callback =
  577. base::BindOnce(&OSExchangeDataWinTest::OnGotVirtualFilesAsTempFiles,
  578. base::Unretained(this));
  579. EXPECT_TRUE(copy.GetVirtualFilesAsTempFiles(std::move(callback)));
  580. // RunUntilIdle assures all async tasks are run.
  581. task_environment_.RunUntilIdle();
  582. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  583. for (size_t i = 0; i < retrieved_virtual_files_.size(); i++) {
  584. // Check that display name is unique.
  585. for (size_t j = 0; j < i; j++) {
  586. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  587. retrieved_virtual_files_[j].display_name.value(),
  588. retrieved_virtual_files_[i].display_name.value()));
  589. }
  590. // Check that temp file path is unique.
  591. for (size_t j = 0; j < i; j++) {
  592. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  593. retrieved_virtual_files_[j].path.value(),
  594. retrieved_virtual_files_[i].path.value()));
  595. }
  596. // Check if the temp files that back the virtual files are actually
  597. // created in the temp directory. Need to compare long file paths here
  598. // because GetTempDir can return a short ("8.3") path if the test is run
  599. // under a username that is too long.
  600. EXPECT_EQ(
  601. base::MakeLongFilePath(temp_dir),
  602. base::MakeLongFilePath(retrieved_virtual_files_[i].path.DirName()));
  603. EXPECT_EQ(kTestFilenamesAndContents[i].first.Extension(),
  604. retrieved_virtual_files_[i].path.Extension());
  605. std::string read_contents;
  606. EXPECT_TRUE(base::ReadFileToString(retrieved_virtual_files_[i].path,
  607. &read_contents));
  608. if (tymed != TYMED_ISTORAGE) {
  609. EXPECT_EQ(kTestFilenamesAndContents[i].second, read_contents);
  610. } else {
  611. // IStorage uses compound files, so temp files won't be flat text files.
  612. // Just make sure the original contents appears in the compound files.
  613. EXPECT_TRUE(
  614. base::Contains(read_contents, kTestFilenamesAndContents[i].second));
  615. }
  616. }
  617. }
  618. }
  619. TEST_F(OSExchangeDataWinTest, VirtualFilesInvalidAndDuplicateNames) {
  620. const std::wstring kInvalidFileNameCharacters(
  621. FILE_PATH_LITERAL("\\/:*?\"<>|"));
  622. const std::wstring kInvalidFilePathCharacters(FILE_PATH_LITERAL("/*?\"<>|"));
  623. const base::FilePath kPathWithInvalidFileNameCharacters =
  624. base::FilePath(kInvalidFileNameCharacters)
  625. .AddExtension(FILE_PATH_LITERAL("txt"));
  626. const base::FilePath kEmptyDisplayName(FILE_PATH_LITERAL(""));
  627. const base::FilePath kMaxPathDisplayName =
  628. base::FilePath(std::wstring(MAX_PATH - 5, L'a'))
  629. .AddExtension(FILE_PATH_LITERAL("txt"));
  630. const std::vector<std::pair<base::FilePath, std::string>>
  631. kTestFilenamesAndContents = {
  632. {kPathWithInvalidFileNameCharacters, std::string("just some data")},
  633. {kPathWithInvalidFileNameCharacters,
  634. std::string("just some data\0with\0nulls", 25)},
  635. {// Test that still get a unique name if a previous uniquified
  636. // name is a duplicate of this one.
  637. kPathWithInvalidFileNameCharacters.InsertBeforeExtension(
  638. FILE_PATH_LITERAL(" (1)")),
  639. std::string("just some more data")},
  640. // Expect a default display name to be generated ("download" if it
  641. // matters).
  642. {kEmptyDisplayName, std::string("data for an empty display name")},
  643. {kEmptyDisplayName,
  644. std::string("data for another empty display name")},
  645. // Expect good behavior if the display name length exceeds MAX_PATH.
  646. {kMaxPathDisplayName,
  647. std::string("data for a >MAX_PATH display name")},
  648. {kMaxPathDisplayName,
  649. std::string("data for another >MAX_PATH display name")},
  650. };
  651. for (const auto& tymed : kStorageMediaTypesForVirtualFiles) {
  652. OSExchangeData data;
  653. data.provider().SetVirtualFileContentsForTesting(kTestFilenamesAndContents,
  654. tymed);
  655. OSExchangeData copy(data.provider().Clone());
  656. std::vector<FileInfo> file_infos;
  657. EXPECT_TRUE(copy.GetVirtualFilenames(&file_infos));
  658. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  659. for (size_t i = 0; i < file_infos.size(); i++) {
  660. // Check that display name does not contain invalid characters.
  661. EXPECT_EQ(std::wstring::npos,
  662. file_infos[i].display_name.value().find_first_of(
  663. kInvalidFileNameCharacters));
  664. // Check that display name is unique.
  665. for (size_t j = 0; j < i; j++) {
  666. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  667. file_infos[j].display_name.value(),
  668. file_infos[i].display_name.value()));
  669. }
  670. }
  671. base::FilePath temp_dir;
  672. EXPECT_TRUE(base::GetTempDir(&temp_dir));
  673. // Callback for GetVirtualFilesAsTempFiles is executed when all virtual
  674. // files are backed by temp files.
  675. auto callback =
  676. base::BindOnce(&OSExchangeDataWinTest::OnGotVirtualFilesAsTempFiles,
  677. base::Unretained(this));
  678. EXPECT_TRUE(copy.GetVirtualFilesAsTempFiles(std::move(callback)));
  679. // RunUntilIdle assures all async tasks are run.
  680. task_environment_.RunUntilIdle();
  681. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  682. for (size_t i = 0; i < retrieved_virtual_files_.size(); i++) {
  683. // Check that display name does not contain invalid characters.
  684. EXPECT_EQ(std::wstring::npos,
  685. retrieved_virtual_files_[i].display_name.value().find_first_of(
  686. kInvalidFileNameCharacters));
  687. // Check that display name is unique.
  688. for (size_t j = 0; j < i; j++) {
  689. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  690. retrieved_virtual_files_[j].display_name.value(),
  691. retrieved_virtual_files_[i].display_name.value()));
  692. }
  693. // Check that temp file path does not contain invalid characters (except
  694. // for separator).
  695. EXPECT_EQ(std::wstring::npos,
  696. retrieved_virtual_files_[i].path.value().find_first_of(
  697. kInvalidFilePathCharacters));
  698. // Check that temp file path is unique.
  699. for (size_t j = 0; j < i; j++) {
  700. EXPECT_FALSE(base::FilePath::CompareEqualIgnoreCase(
  701. retrieved_virtual_files_[j].path.value(),
  702. retrieved_virtual_files_[i].path.value()));
  703. }
  704. // Check if the temp files that back the virtual files are actually
  705. // created in the temp directory. Need to compare long file paths here
  706. // because GetTempDir can return a short ("8.3") path if the test is run
  707. // under a username that is too long.
  708. EXPECT_EQ(
  709. base::MakeLongFilePath(temp_dir),
  710. base::MakeLongFilePath(retrieved_virtual_files_[i].path.DirName()));
  711. EXPECT_EQ(kTestFilenamesAndContents[i].first.Extension(),
  712. retrieved_virtual_files_[i].path.Extension());
  713. std::string read_contents;
  714. // Ability to read the contents implies a temp file was successfully
  715. // created on the file system even though the original suggested display
  716. // name had invalid filename characters.
  717. EXPECT_TRUE(base::ReadFileToString(retrieved_virtual_files_[i].path,
  718. &read_contents));
  719. if (tymed != TYMED_ISTORAGE) {
  720. EXPECT_EQ(kTestFilenamesAndContents[i].second, read_contents);
  721. } else {
  722. // IStorage uses compound files, so temp files won't be flat text files.
  723. // Just make sure the original contents appears in the compound files.
  724. EXPECT_TRUE(
  725. base::Contains(read_contents, kTestFilenamesAndContents[i].second));
  726. }
  727. }
  728. }
  729. }
  730. TEST_F(OSExchangeDataWinTest, VirtualFilesEmptyContents) {
  731. const std::vector<std::pair<base::FilePath, std::string>>
  732. kTestFilenamesAndContents = {
  733. {base::FilePath(FILE_PATH_LITERAL("file_with_no_contents.txt")),
  734. std::string()},
  735. };
  736. for (const auto& tymed : kStorageMediaTypesForVirtualFiles) {
  737. OSExchangeData data;
  738. data.provider().SetVirtualFileContentsForTesting(kTestFilenamesAndContents,
  739. tymed);
  740. OSExchangeData copy(data.provider().Clone());
  741. std::vector<FileInfo> file_infos;
  742. EXPECT_TRUE(copy.GetVirtualFilenames(&file_infos));
  743. EXPECT_EQ(kTestFilenamesAndContents.size(), file_infos.size());
  744. for (size_t i = 0; i < file_infos.size(); i++) {
  745. EXPECT_EQ(kTestFilenamesAndContents[i].first, file_infos[i].display_name);
  746. }
  747. base::FilePath temp_dir;
  748. EXPECT_TRUE(base::GetTempDir(&temp_dir));
  749. // Callback for GetVirtualFilesAsTempFiles is executed when all virtual
  750. // files are backed by temp files.
  751. auto callback =
  752. base::BindOnce(&OSExchangeDataWinTest::OnGotVirtualFilesAsTempFiles,
  753. base::Unretained(this));
  754. EXPECT_TRUE(copy.GetVirtualFilesAsTempFiles(std::move(callback)));
  755. // RunUntilIdle assures all async tasks are run.
  756. task_environment_.RunUntilIdle();
  757. EXPECT_EQ(kTestFilenamesAndContents.size(),
  758. retrieved_virtual_files_.size());
  759. for (size_t i = 0; i < retrieved_virtual_files_.size(); i++) {
  760. EXPECT_EQ(kTestFilenamesAndContents[i].first,
  761. retrieved_virtual_files_[i].display_name);
  762. // Check if the temp files that back the virtual files are actually
  763. // created in the temp directory. Need to compare long file paths here
  764. // because GetTempDir can return a short ("8.3") path if the test is run
  765. // under a username that is too long.
  766. EXPECT_EQ(
  767. base::MakeLongFilePath(temp_dir),
  768. base::MakeLongFilePath(retrieved_virtual_files_[i].path.DirName()));
  769. EXPECT_EQ(kTestFilenamesAndContents[i].first.Extension(),
  770. retrieved_virtual_files_[i].path.Extension());
  771. std::string read_contents;
  772. EXPECT_TRUE(base::ReadFileToString(retrieved_virtual_files_[i].path,
  773. &read_contents));
  774. // IStorage uses compound files, so temp files won't be flat text files.
  775. // Just make sure the original contents appear in the compound files.
  776. if (tymed != TYMED_ISTORAGE) {
  777. EXPECT_EQ(kTestFilenamesAndContents[i].second, read_contents);
  778. EXPECT_EQ(static_cast<size_t>(0), read_contents.length());
  779. }
  780. }
  781. }
  782. }
  783. TEST_F(OSExchangeDataWinTest, CFHtml) {
  784. OSExchangeData data;
  785. GURL url("http://www.google.com/");
  786. std::u16string html(
  787. u"<HTML>\n<BODY>\n"
  788. u"<b>bold.</b> <i><b>This is bold italic.</b></i>\n"
  789. u"</BODY>\n</HTML>");
  790. data.SetHtml(html, url);
  791. // Check the CF_HTML too.
  792. std::string expected_cf_html(
  793. "Version:0.9\r\nStartHTML:0000000139\r\nEndHTML:0000000288\r\n"
  794. "StartFragment:0000000175\r\nEndFragment:0000000252\r\n"
  795. "SourceURL:http://www.google.com/\r\n<html>\r\n<body>\r\n"
  796. "<!--StartFragment-->");
  797. expected_cf_html += base::UTF16ToUTF8(html);
  798. expected_cf_html.append("<!--EndFragment-->\r\n</body>\r\n</html>");
  799. FORMATETC format = ClipboardFormatType::HtmlType().ToFormatEtc();
  800. STGMEDIUM medium;
  801. IDataObject* data_object = OSExchangeDataProviderWin::GetIDataObject(data);
  802. EXPECT_EQ(S_OK, data_object->GetData(&format, &medium));
  803. base::win::ScopedHGlobal<char*> glob(medium.hGlobal);
  804. std::string output(glob.get(), glob.Size());
  805. EXPECT_EQ(expected_cf_html, output);
  806. ReleaseStgMedium(&medium);
  807. }
  808. TEST_F(OSExchangeDataWinTest, SetURLWithMaxPath) {
  809. OSExchangeData data;
  810. std::u16string long_title(MAX_PATH + 1, u'a');
  811. data.SetURL(GURL("http://google.com"), long_title);
  812. }
  813. TEST_F(OSExchangeDataWinTest, ProvideURLForPlainTextURL) {
  814. OSExchangeData data;
  815. data.SetString(u"http://google.com");
  816. OSExchangeData data2(data.provider().Clone());
  817. ASSERT_TRUE(data2.HasURL(FilenameToURLPolicy::CONVERT_FILENAMES));
  818. GURL read_url;
  819. std::u16string title;
  820. EXPECT_TRUE(data2.GetURLAndTitle(FilenameToURLPolicy::CONVERT_FILENAMES,
  821. &read_url, &title));
  822. EXPECT_EQ(GURL("http://google.com"), read_url);
  823. }
  824. class MockDownloadFileProvider : public DownloadFileProvider {
  825. public:
  826. MockDownloadFileProvider() = default;
  827. ~MockDownloadFileProvider() override = default;
  828. base::WeakPtr<MockDownloadFileProvider> GetWeakPtr() {
  829. return weak_ptr_factory_.GetWeakPtr();
  830. }
  831. MOCK_METHOD1(Start, void(DownloadFileObserver* observer));
  832. MOCK_METHOD0(Wait, bool());
  833. MOCK_METHOD0(Stop, void());
  834. private:
  835. base::WeakPtrFactory<MockDownloadFileProvider> weak_ptr_factory_{this};
  836. };
  837. // Verifies that DataObjectImpl::OnDownloadCompleted() doesn't delete
  838. // the DownloadFileProvider instance.
  839. TEST_F(OSExchangeDataWinTest, OnDownloadCompleted) {
  840. OSExchangeData data;
  841. Microsoft::WRL::ComPtr<IDataObject> com_data(
  842. OSExchangeDataProviderWin::GetIDataObject(data));
  843. OSExchangeDataProviderWin provider(com_data.Get());
  844. auto download_file_provider = std::make_unique<MockDownloadFileProvider>();
  845. auto weak_ptr = download_file_provider->GetWeakPtr();
  846. DownloadFileInfo file_info(
  847. base::FilePath(FILE_PATH_LITERAL("file_with_no_contents.txt")),
  848. std::move(download_file_provider));
  849. provider.SetDownloadFileInfo(&file_info);
  850. OSExchangeDataProviderWin::GetDataObjectImpl(data)->OnDownloadCompleted(
  851. base::FilePath());
  852. EXPECT_TRUE(weak_ptr);
  853. }
  854. // Verifies the data set by DataObjectImpl::SetData with |fRelease| is released
  855. // correctly after the DataObjectImpl instance is destroyed.
  856. TEST_F(OSExchangeDataWinTest, SetDataRelease) {
  857. RefCountMockStream stream;
  858. ASSERT_EQ(stream.AddRef(), 1u);
  859. {
  860. OSExchangeDataProviderWin data_provider;
  861. IDataObject* data_object = data_provider.data_object();
  862. ClipboardFormatType format(
  863. /* cfFormat= */ CF_TEXT, /* lindex= */ -1, /* tymed= */ TYMED_ISTREAM);
  864. FORMATETC format_etc = format.ToFormatEtc();
  865. STGMEDIUM medium;
  866. medium.tymed = TYMED_ISTREAM;
  867. medium.pstm = &stream;
  868. medium.pUnkForRelease = nullptr;
  869. // |stream| should be released when |data_object| is destroyed since it
  870. // takes responsibility to release |stream| after used.
  871. EXPECT_EQ(S_OK,
  872. data_object->SetData(&format_etc, &medium, /* fRelease= */ TRUE));
  873. ASSERT_EQ(stream.GetRefCount(), 1u);
  874. }
  875. EXPECT_EQ(stream.GetRefCount(), 0u);
  876. }
  877. // Verifies the data duplicated by DataObjectImpl::SetData without |fRelease|
  878. // is released correctly after the DataObjectImpl instance destroyed.
  879. TEST_F(OSExchangeDataWinTest, SetDataNoRelease) {
  880. RefCountMockStream stream;
  881. ASSERT_EQ(stream.GetRefCount(), 0u);
  882. {
  883. OSExchangeDataProviderWin data_provider;
  884. IDataObject* data_object = data_provider.data_object();
  885. ClipboardFormatType format(
  886. /* cfFormat= */ CF_TEXT, /* lindex= */ -1, /* tymed= */ TYMED_ISTREAM);
  887. FORMATETC format_etc = format.ToFormatEtc();
  888. STGMEDIUM medium;
  889. medium.tymed = TYMED_ISTREAM;
  890. medium.pstm = &stream;
  891. medium.pUnkForRelease = nullptr;
  892. EXPECT_EQ(S_OK, data_object->SetData(&format_etc, &medium,
  893. /* fRelease= */ FALSE));
  894. ASSERT_EQ(stream.GetRefCount(), 1u);
  895. }
  896. // Reference count should be the same as before if |data_object| is
  897. // destroyed.
  898. EXPECT_EQ(stream.GetRefCount(), 0u);
  899. }
  900. } // namespace ui