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 "ui/base/dragdrop/os_exchange_data_provider_win.h" 6 7 #include <algorithm> 8 9 #include "base/basictypes.h" 10 #include "base/files/file_path.h" 11 #include "base/i18n/file_util_icu.h" 12 #include "base/logging.h" 13 #include "base/pickle.h" 14 #include "base/strings/utf_string_conversions.h" 15 #include "base/win/scoped_hglobal.h" 16 #include "grit/ui_strings.h" 17 #include "net/base/filename_util.h" 18 #include "ui/base/clipboard/clipboard.h" 19 #include "ui/base/clipboard/clipboard_util_win.h" 20 #include "ui/base/dragdrop/file_info.h" 21 #include "ui/base/l10n/l10n_util.h" 22 #include "url/gurl.h" 23 24 namespace ui { 25 26 static const OSExchangeData::CustomFormat& GetRendererTaintCustomType() { 27 CR_DEFINE_STATIC_LOCAL( 28 ui::OSExchangeData::CustomFormat, 29 format, 30 (ui::Clipboard::GetFormatType("chromium/x-renderer-taint"))); 31 return format; 32 } 33 34 // Creates a new STGMEDIUM object to hold the specified text. The caller 35 // owns the resulting object. The "Bytes" version does not NULL terminate, the 36 // string version does. 37 static STGMEDIUM* GetStorageForBytes(const void* data, size_t bytes); 38 template <typename T> 39 static STGMEDIUM* GetStorageForString(const std::basic_string<T>& data); 40 // Creates the contents of an Internet Shortcut file for the given URL. 41 static void GetInternetShortcutFileContents(const GURL& url, std::string* data); 42 // Creates a valid file name given a suggested title and URL. 43 static void CreateValidFileNameFromTitle(const GURL& url, 44 const base::string16& title, 45 base::string16* validated); 46 // Creates a new STGMEDIUM object to hold a file. 47 static STGMEDIUM* GetStorageForFileName(const base::FilePath& path); 48 static STGMEDIUM* GetIDListStorageForFileName(const base::FilePath& path); 49 // Creates a File Descriptor for the creation of a file to the given URL and 50 // returns a handle to it. 51 static STGMEDIUM* GetStorageForFileDescriptor(const base::FilePath& path); 52 53 /////////////////////////////////////////////////////////////////////////////// 54 // FormatEtcEnumerator 55 56 // 57 // This object implements an enumeration interface. The existence of an 58 // implementation of this interface is exposed to clients through 59 // OSExchangeData's EnumFormatEtc method. Our implementation is nobody's 60 // business but our own, so it lives in this file. 61 // 62 // This Windows API is truly a gem. It wants to be an enumerator but assumes 63 // some sort of sequential data (why not just use an array?). See comments 64 // throughout. 65 // 66 class FormatEtcEnumerator FINAL : public IEnumFORMATETC { 67 public: 68 FormatEtcEnumerator(DataObjectImpl::StoredData::const_iterator begin, 69 DataObjectImpl::StoredData::const_iterator end); 70 ~FormatEtcEnumerator(); 71 72 // IEnumFORMATETC implementation: 73 HRESULT __stdcall Next( 74 ULONG count, FORMATETC* elements_array, ULONG* elements_fetched); 75 HRESULT __stdcall Skip(ULONG skip_count); 76 HRESULT __stdcall Reset(); 77 HRESULT __stdcall Clone(IEnumFORMATETC** clone); 78 79 // IUnknown implementation: 80 HRESULT __stdcall QueryInterface(const IID& iid, void** object); 81 ULONG __stdcall AddRef(); 82 ULONG __stdcall Release(); 83 84 private: 85 // This can only be called from |CloneFromOther|, since it initializes the 86 // contents_ from the other enumerator's contents. 87 FormatEtcEnumerator() : cursor_(0), ref_count_(0) { 88 } 89 90 // Clone a new FormatEtc from another instance of this enumeration. 91 static FormatEtcEnumerator* CloneFromOther(const FormatEtcEnumerator* other); 92 93 private: 94 // We are _forced_ to use a vector as our internal data model as Windows' 95 // retarded IEnumFORMATETC API assumes a deterministic ordering of elements 96 // through methods like Next and Skip. This exposes the underlying data 97 // structure to the user. Bah. 98 ScopedVector<FORMATETC> contents_; 99 100 // The cursor of the active enumeration - an index into |contents_|. 101 size_t cursor_; 102 103 LONG ref_count_; 104 105 DISALLOW_COPY_AND_ASSIGN(FormatEtcEnumerator); 106 }; 107 108 // Safely makes a copy of all of the relevant bits of a FORMATETC object. 109 static void CloneFormatEtc(FORMATETC* source, FORMATETC* clone) { 110 *clone = *source; 111 if (source->ptd) { 112 source->ptd = 113 static_cast<DVTARGETDEVICE*>(CoTaskMemAlloc(sizeof(DVTARGETDEVICE))); 114 *(clone->ptd) = *(source->ptd); 115 } 116 } 117 118 FormatEtcEnumerator::FormatEtcEnumerator( 119 DataObjectImpl::StoredData::const_iterator start, 120 DataObjectImpl::StoredData::const_iterator end) 121 : ref_count_(0), cursor_(0) { 122 // Copy FORMATETC data from our source into ourselves. 123 while (start != end) { 124 FORMATETC* format_etc = new FORMATETC; 125 CloneFormatEtc(&(*start)->format_etc, format_etc); 126 contents_.push_back(format_etc); 127 ++start; 128 } 129 } 130 131 FormatEtcEnumerator::~FormatEtcEnumerator() { 132 } 133 134 STDMETHODIMP FormatEtcEnumerator::Next( 135 ULONG count, FORMATETC* elements_array, ULONG* elements_fetched) { 136 // MSDN says |elements_fetched| is allowed to be NULL if count is 1. 137 if (!elements_fetched) 138 DCHECK_EQ(count, 1ul); 139 140 // This method copies count elements into |elements_array|. 141 ULONG index = 0; 142 while (cursor_ < contents_.size() && index < count) { 143 CloneFormatEtc(contents_[cursor_], &elements_array[index]); 144 ++cursor_; 145 ++index; 146 } 147 // The out param is for how many we actually copied. 148 if (elements_fetched) 149 *elements_fetched = index; 150 151 // If the two don't agree, then we fail. 152 return index == count ? S_OK : S_FALSE; 153 } 154 155 STDMETHODIMP FormatEtcEnumerator::Skip(ULONG skip_count) { 156 cursor_ += skip_count; 157 // MSDN implies it's OK to leave the enumerator trashed. 158 // "Whatever you say, boss" 159 return cursor_ <= contents_.size() ? S_OK : S_FALSE; 160 } 161 162 STDMETHODIMP FormatEtcEnumerator::Reset() { 163 cursor_ = 0; 164 return S_OK; 165 } 166 167 STDMETHODIMP FormatEtcEnumerator::Clone(IEnumFORMATETC** clone) { 168 // Clone the current enumerator in its exact state, including cursor. 169 FormatEtcEnumerator* e = CloneFromOther(this); 170 e->AddRef(); 171 *clone = e; 172 return S_OK; 173 } 174 175 STDMETHODIMP FormatEtcEnumerator::QueryInterface(const IID& iid, 176 void** object) { 177 *object = NULL; 178 if (IsEqualIID(iid, IID_IUnknown) || IsEqualIID(iid, IID_IEnumFORMATETC)) { 179 *object = this; 180 } else { 181 return E_NOINTERFACE; 182 } 183 AddRef(); 184 return S_OK; 185 } 186 187 ULONG FormatEtcEnumerator::AddRef() { 188 return InterlockedIncrement(&ref_count_); 189 } 190 191 ULONG FormatEtcEnumerator::Release() { 192 if (InterlockedDecrement(&ref_count_) == 0) { 193 ULONG copied_refcnt = ref_count_; 194 delete this; 195 return copied_refcnt; 196 } 197 return ref_count_; 198 } 199 200 // static 201 FormatEtcEnumerator* FormatEtcEnumerator::CloneFromOther( 202 const FormatEtcEnumerator* other) { 203 FormatEtcEnumerator* e = new FormatEtcEnumerator; 204 // Copy FORMATETC data from our source into ourselves. 205 ScopedVector<FORMATETC>::const_iterator start = other->contents_.begin(); 206 while (start != other->contents_.end()) { 207 FORMATETC* format_etc = new FORMATETC; 208 CloneFormatEtc(*start, format_etc); 209 e->contents_.push_back(format_etc); 210 ++start; 211 } 212 // Carry over 213 e->cursor_ = other->cursor_; 214 return e; 215 } 216 217 /////////////////////////////////////////////////////////////////////////////// 218 // OSExchangeDataProviderWin, public: 219 220 // static 221 bool OSExchangeDataProviderWin::HasPlainTextURL(IDataObject* source) { 222 base::string16 plain_text; 223 return (ClipboardUtil::GetPlainText(source, &plain_text) && 224 !plain_text.empty() && GURL(plain_text).is_valid()); 225 } 226 227 // static 228 bool OSExchangeDataProviderWin::GetPlainTextURL(IDataObject* source, 229 GURL* url) { 230 base::string16 plain_text; 231 if (ClipboardUtil::GetPlainText(source, &plain_text) && 232 !plain_text.empty()) { 233 GURL gurl(plain_text); 234 if (gurl.is_valid()) { 235 *url = gurl; 236 return true; 237 } 238 } 239 return false; 240 } 241 242 // static 243 DataObjectImpl* OSExchangeDataProviderWin::GetDataObjectImpl( 244 const OSExchangeData& data) { 245 return static_cast<const OSExchangeDataProviderWin*>(&data.provider())-> 246 data_.get(); 247 } 248 249 // static 250 IDataObject* OSExchangeDataProviderWin::GetIDataObject( 251 const OSExchangeData& data) { 252 return static_cast<const OSExchangeDataProviderWin*>(&data.provider())-> 253 data_object(); 254 } 255 256 // static 257 IDataObjectAsyncCapability* OSExchangeDataProviderWin::GetIAsyncOperation( 258 const OSExchangeData& data) { 259 return static_cast<const OSExchangeDataProviderWin*>(&data.provider())-> 260 async_operation(); 261 } 262 263 OSExchangeDataProviderWin::OSExchangeDataProviderWin(IDataObject* source) 264 : data_(new DataObjectImpl()), 265 source_object_(source) { 266 } 267 268 OSExchangeDataProviderWin::OSExchangeDataProviderWin() 269 : data_(new DataObjectImpl()), 270 source_object_(data_.get()) { 271 } 272 273 OSExchangeDataProviderWin::~OSExchangeDataProviderWin() { 274 } 275 276 OSExchangeData::Provider* OSExchangeDataProviderWin::Clone() const { 277 return new OSExchangeDataProviderWin(data_object()); 278 } 279 280 void OSExchangeDataProviderWin::MarkOriginatedFromRenderer() { 281 STGMEDIUM* storage = GetStorageForString(std::string()); 282 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 283 GetRendererTaintCustomType().ToFormatEtc(), storage)); 284 } 285 286 bool OSExchangeDataProviderWin::DidOriginateFromRenderer() const { 287 return HasCustomFormat(GetRendererTaintCustomType()); 288 } 289 290 void OSExchangeDataProviderWin::SetString(const base::string16& data) { 291 STGMEDIUM* storage = GetStorageForString(data); 292 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 293 Clipboard::GetPlainTextWFormatType().ToFormatEtc(), storage)); 294 295 // Also add the UTF8-encoded version. 296 storage = GetStorageForString(base::UTF16ToUTF8(data)); 297 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 298 Clipboard::GetPlainTextFormatType().ToFormatEtc(), storage)); 299 } 300 301 void OSExchangeDataProviderWin::SetURL(const GURL& url, 302 const base::string16& title) { 303 // NOTE WELL: 304 // Every time you change the order of the first two CLIPFORMATS that get 305 // added here, you need to update the EnumerationViaCOM test case in 306 // the _unittest.cc file to reflect the new arrangement otherwise that test 307 // will fail! It assumes an insertion order. 308 309 // Add text/x-moz-url for drags from Firefox 310 base::string16 x_moz_url_str = base::UTF8ToUTF16(url.spec()); 311 x_moz_url_str += '\n'; 312 x_moz_url_str += title; 313 STGMEDIUM* storage = GetStorageForString(x_moz_url_str); 314 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 315 Clipboard::GetMozUrlFormatType().ToFormatEtc(), storage)); 316 317 // Add a .URL shortcut file for dragging to Explorer. 318 base::string16 valid_file_name; 319 CreateValidFileNameFromTitle(url, title, &valid_file_name); 320 std::string shortcut_url_file_contents; 321 GetInternetShortcutFileContents(url, &shortcut_url_file_contents); 322 SetFileContents(base::FilePath(valid_file_name), shortcut_url_file_contents); 323 324 // Add a UniformResourceLocator link for apps like IE and Word. 325 storage = GetStorageForString(base::UTF8ToUTF16(url.spec())); 326 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 327 Clipboard::GetUrlWFormatType().ToFormatEtc(), storage)); 328 storage = GetStorageForString(url.spec()); 329 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 330 Clipboard::GetUrlFormatType().ToFormatEtc(), storage)); 331 332 // TODO(beng): add CF_HTML. 333 // http://code.google.com/p/chromium/issues/detail?id=6767 334 335 // Also add text representations (these should be last since they're the 336 // least preferable). 337 SetString(base::UTF8ToUTF16(url.spec())); 338 } 339 340 void OSExchangeDataProviderWin::SetFilename(const base::FilePath& path) { 341 STGMEDIUM* storage = GetStorageForFileName(path); 342 DataObjectImpl::StoredDataInfo* info = new DataObjectImpl::StoredDataInfo( 343 Clipboard::GetCFHDropFormatType().ToFormatEtc(), storage); 344 data_->contents_.push_back(info); 345 346 storage = GetIDListStorageForFileName(path); 347 if (!storage) 348 return; 349 info = new DataObjectImpl::StoredDataInfo( 350 Clipboard::GetIDListFormatType().ToFormatEtc(), storage); 351 data_->contents_.push_back(info); 352 } 353 354 void OSExchangeDataProviderWin::SetFilenames( 355 const std::vector<FileInfo>& filenames) { 356 for (size_t i = 0; i < filenames.size(); ++i) { 357 STGMEDIUM* storage = GetStorageForFileName(filenames[i].path); 358 DataObjectImpl::StoredDataInfo* info = new DataObjectImpl::StoredDataInfo( 359 Clipboard::GetCFHDropFormatType().ToFormatEtc(), storage); 360 data_->contents_.push_back(info); 361 } 362 } 363 364 void OSExchangeDataProviderWin::SetPickledData( 365 const OSExchangeData::CustomFormat& format, 366 const Pickle& data) { 367 STGMEDIUM* storage = GetStorageForBytes(data.data(), data.size()); 368 data_->contents_.push_back( 369 new DataObjectImpl::StoredDataInfo(format.ToFormatEtc(), storage)); 370 } 371 372 void OSExchangeDataProviderWin::SetFileContents( 373 const base::FilePath& filename, 374 const std::string& file_contents) { 375 // Add CFSTR_FILEDESCRIPTOR 376 STGMEDIUM* storage = GetStorageForFileDescriptor(filename); 377 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 378 Clipboard::GetFileDescriptorFormatType().ToFormatEtc(), storage)); 379 380 // Add CFSTR_FILECONTENTS 381 storage = GetStorageForBytes(file_contents.data(), file_contents.length()); 382 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 383 Clipboard::GetFileContentZeroFormatType().ToFormatEtc(), storage)); 384 } 385 386 void OSExchangeDataProviderWin::SetHtml(const base::string16& html, 387 const GURL& base_url) { 388 // Add both MS CF_HTML and text/html format. CF_HTML should be in utf-8. 389 std::string utf8_html = base::UTF16ToUTF8(html); 390 std::string url = base_url.is_valid() ? base_url.spec() : std::string(); 391 392 std::string cf_html = ClipboardUtil::HtmlToCFHtml(utf8_html, url); 393 STGMEDIUM* storage = GetStorageForBytes(cf_html.c_str(), cf_html.size()); 394 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 395 Clipboard::GetHtmlFormatType().ToFormatEtc(), storage)); 396 397 STGMEDIUM* storage_plain = GetStorageForBytes(utf8_html.c_str(), 398 utf8_html.size()); 399 data_->contents_.push_back(new DataObjectImpl::StoredDataInfo( 400 Clipboard::GetTextHtmlFormatType().ToFormatEtc(), storage_plain)); 401 } 402 403 bool OSExchangeDataProviderWin::GetString(base::string16* data) const { 404 return ClipboardUtil::GetPlainText(source_object_, data); 405 } 406 407 bool OSExchangeDataProviderWin::GetURLAndTitle( 408 OSExchangeData::FilenameToURLPolicy policy, 409 GURL* url, 410 base::string16* title) const { 411 base::string16 url_str; 412 bool success = ClipboardUtil::GetUrl( 413 source_object_, 414 &url_str, 415 title, 416 policy == OSExchangeData::CONVERT_FILENAMES ? true : false); 417 if (success) { 418 GURL test_url(url_str); 419 if (test_url.is_valid()) { 420 *url = test_url; 421 return true; 422 } 423 } else if (GetPlainTextURL(source_object_, url)) { 424 if (url->is_valid()) 425 *title = net::GetSuggestedFilename(*url, "", "", "", "", std::string()); 426 else 427 title->clear(); 428 return true; 429 } 430 return false; 431 } 432 433 bool OSExchangeDataProviderWin::GetFilename(base::FilePath* path) const { 434 std::vector<base::string16> filenames; 435 bool success = ClipboardUtil::GetFilenames(source_object_, &filenames); 436 if (success) 437 *path = base::FilePath(filenames[0]); 438 return success; 439 } 440 441 bool OSExchangeDataProviderWin::GetFilenames( 442 std::vector<FileInfo>* filenames) const { 443 std::vector<base::string16> filenames_local; 444 bool success = ClipboardUtil::GetFilenames(source_object_, &filenames_local); 445 if (success) { 446 for (size_t i = 0; i < filenames_local.size(); ++i) 447 filenames->push_back( 448 FileInfo(base::FilePath(filenames_local[i]), base::FilePath())); 449 } 450 return success; 451 } 452 453 bool OSExchangeDataProviderWin::GetPickledData( 454 const OSExchangeData::CustomFormat& format, 455 Pickle* data) const { 456 DCHECK(data); 457 bool success = false; 458 STGMEDIUM medium; 459 FORMATETC format_etc = format.ToFormatEtc(); 460 if (SUCCEEDED(source_object_->GetData(&format_etc, &medium))) { 461 if (medium.tymed & TYMED_HGLOBAL) { 462 base::win::ScopedHGlobal<char> c_data(medium.hGlobal); 463 DCHECK_GT(c_data.Size(), 0u); 464 *data = Pickle(c_data.get(), static_cast<int>(c_data.Size())); 465 success = true; 466 } 467 ReleaseStgMedium(&medium); 468 } 469 return success; 470 } 471 472 bool OSExchangeDataProviderWin::GetFileContents( 473 base::FilePath* filename, 474 std::string* file_contents) const { 475 base::string16 filename_str; 476 if (!ClipboardUtil::GetFileContents(source_object_, &filename_str, 477 file_contents)) { 478 return false; 479 } 480 *filename = base::FilePath(filename_str); 481 return true; 482 } 483 484 bool OSExchangeDataProviderWin::GetHtml(base::string16* html, 485 GURL* base_url) const { 486 std::string url; 487 bool success = ClipboardUtil::GetHtml(source_object_, html, &url); 488 if (success) 489 *base_url = GURL(url); 490 return success; 491 } 492 493 bool OSExchangeDataProviderWin::HasString() const { 494 return ClipboardUtil::HasPlainText(source_object_); 495 } 496 497 bool OSExchangeDataProviderWin::HasURL( 498 OSExchangeData::FilenameToURLPolicy policy) const { 499 return (ClipboardUtil::HasUrl( 500 source_object_, 501 policy == OSExchangeData::CONVERT_FILENAMES ? true : false) || 502 HasPlainTextURL(source_object_)); 503 } 504 505 bool OSExchangeDataProviderWin::HasFile() const { 506 return ClipboardUtil::HasFilenames(source_object_); 507 } 508 509 bool OSExchangeDataProviderWin::HasFileContents() const { 510 return ClipboardUtil::HasFileContents(source_object_); 511 } 512 513 bool OSExchangeDataProviderWin::HasHtml() const { 514 return ClipboardUtil::HasHtml(source_object_); 515 } 516 517 bool OSExchangeDataProviderWin::HasCustomFormat( 518 const OSExchangeData::CustomFormat& format) const { 519 FORMATETC format_etc = format.ToFormatEtc(); 520 return (source_object_->QueryGetData(&format_etc) == S_OK); 521 } 522 523 void OSExchangeDataProviderWin::SetDownloadFileInfo( 524 const OSExchangeData::DownloadFileInfo& download) { 525 // If the filename is not provided, set storage to NULL to indicate that 526 // the delay rendering will be used. 527 // TODO(dcheng): Is it actually possible for filename to be empty here? I 528 // think we always synthesize one in WebContentsDragWin. 529 STGMEDIUM* storage = NULL; 530 if (!download.filename.empty()) 531 storage = GetStorageForFileName(download.filename); 532 533 // Add CF_HDROP. 534 DataObjectImpl::StoredDataInfo* info = new DataObjectImpl::StoredDataInfo( 535 Clipboard::GetCFHDropFormatType().ToFormatEtc(), storage); 536 info->downloader = download.downloader; 537 data_->contents_.push_back(info); 538 } 539 540 void OSExchangeDataProviderWin::SetDragImage( 541 const gfx::ImageSkia& image, 542 const gfx::Vector2d& cursor_offset) { 543 drag_image_ = image; 544 drag_image_offset_ = cursor_offset; 545 } 546 547 const gfx::ImageSkia& OSExchangeDataProviderWin::GetDragImage() const { 548 return drag_image_; 549 } 550 551 const gfx::Vector2d& OSExchangeDataProviderWin::GetDragImageOffset() const { 552 return drag_image_offset_; 553 } 554 555 /////////////////////////////////////////////////////////////////////////////// 556 // DataObjectImpl, IDataObject implementation: 557 558 // The following function, DuplicateMedium, is derived from WCDataObject.cpp 559 // in the WebKit source code. This is the license information for the file: 560 /* 561 * Copyright (C) 2007 Apple Inc. All rights reserved. 562 * 563 * Redistribution and use in source and binary forms, with or without 564 * modification, are permitted provided that the following conditions 565 * are met: 566 * 1. Redistributions of source code must retain the above copyright 567 * notice, this list of conditions and the following disclaimer. 568 * 2. Redistributions in binary form must reproduce the above copyright 569 * notice, this list of conditions and the following disclaimer in the 570 * documentation and/or other materials provided with the distribution. 571 * 572 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY 573 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 574 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 575 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR 576 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 577 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 578 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 579 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 580 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 581 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 582 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 583 */ 584 static void DuplicateMedium(CLIPFORMAT source_clipformat, 585 STGMEDIUM* source, 586 STGMEDIUM* destination) { 587 switch (source->tymed) { 588 case TYMED_HGLOBAL: 589 destination->hGlobal = 590 static_cast<HGLOBAL>(OleDuplicateData( 591 source->hGlobal, source_clipformat, 0)); 592 break; 593 case TYMED_MFPICT: 594 destination->hMetaFilePict = 595 static_cast<HMETAFILEPICT>(OleDuplicateData( 596 source->hMetaFilePict, source_clipformat, 0)); 597 break; 598 case TYMED_GDI: 599 destination->hBitmap = 600 static_cast<HBITMAP>(OleDuplicateData( 601 source->hBitmap, source_clipformat, 0)); 602 break; 603 case TYMED_ENHMF: 604 destination->hEnhMetaFile = 605 static_cast<HENHMETAFILE>(OleDuplicateData( 606 source->hEnhMetaFile, source_clipformat, 0)); 607 break; 608 case TYMED_FILE: 609 destination->lpszFileName = 610 static_cast<LPOLESTR>(OleDuplicateData( 611 source->lpszFileName, source_clipformat, 0)); 612 break; 613 case TYMED_ISTREAM: 614 destination->pstm = source->pstm; 615 destination->pstm->AddRef(); 616 break; 617 case TYMED_ISTORAGE: 618 destination->pstg = source->pstg; 619 destination->pstg->AddRef(); 620 break; 621 } 622 623 destination->tymed = source->tymed; 624 destination->pUnkForRelease = source->pUnkForRelease; 625 if (destination->pUnkForRelease) 626 destination->pUnkForRelease->AddRef(); 627 } 628 629 DataObjectImpl::DataObjectImpl() 630 : is_aborting_(false), 631 in_drag_loop_(false), 632 in_async_mode_(false), 633 async_operation_started_(false), 634 observer_(NULL) { 635 } 636 637 DataObjectImpl::~DataObjectImpl() { 638 StopDownloads(); 639 if (observer_) 640 observer_->OnDataObjectDisposed(); 641 } 642 643 void DataObjectImpl::StopDownloads() { 644 for (StoredData::iterator iter = contents_.begin(); 645 iter != contents_.end(); ++iter) { 646 if ((*iter)->downloader.get()) { 647 (*iter)->downloader->Stop(); 648 (*iter)->downloader = 0; 649 } 650 } 651 } 652 653 void DataObjectImpl::RemoveData(const FORMATETC& format) { 654 if (format.ptd) 655 return; // Don't attempt to compare target devices. 656 657 for (StoredData::iterator i = contents_.begin(); i != contents_.end(); ++i) { 658 if (!(*i)->format_etc.ptd && 659 format.cfFormat == (*i)->format_etc.cfFormat && 660 format.dwAspect == (*i)->format_etc.dwAspect && 661 format.lindex == (*i)->format_etc.lindex && 662 format.tymed == (*i)->format_etc.tymed) { 663 contents_.erase(i); 664 return; 665 } 666 } 667 } 668 669 void DataObjectImpl::OnDownloadCompleted(const base::FilePath& file_path) { 670 DataObjectImpl::StoredData::iterator iter = contents_.begin(); 671 for (; iter != contents_.end(); ++iter) { 672 if ((*iter)->format_etc.cfFormat == CF_HDROP) { 673 // Release the old storage. 674 if ((*iter)->owns_medium) { 675 ReleaseStgMedium((*iter)->medium); 676 delete (*iter)->medium; 677 } 678 679 // Update the storage. 680 (*iter)->owns_medium = true; 681 (*iter)->medium = GetStorageForFileName(file_path); 682 683 break; 684 } 685 } 686 DCHECK(iter != contents_.end()); 687 } 688 689 void DataObjectImpl::OnDownloadAborted() { 690 } 691 692 HRESULT DataObjectImpl::GetData(FORMATETC* format_etc, STGMEDIUM* medium) { 693 if (is_aborting_) 694 return DV_E_FORMATETC; 695 696 StoredData::iterator iter = contents_.begin(); 697 while (iter != contents_.end()) { 698 if ((*iter)->format_etc.cfFormat == format_etc->cfFormat && 699 (*iter)->format_etc.lindex == format_etc->lindex && 700 ((*iter)->format_etc.tymed & format_etc->tymed)) { 701 // If medium is NULL, delay-rendering will be used. 702 if ((*iter)->medium) { 703 DuplicateMedium((*iter)->format_etc.cfFormat, (*iter)->medium, medium); 704 } else { 705 // Fail all GetData() attempts for DownloadURL data if the drag and drop 706 // operation is still in progress. 707 if (in_drag_loop_) 708 return DV_E_FORMATETC; 709 710 bool wait_for_data = false; 711 712 // In async mode, we do not want to start waiting for the data before 713 // the async operation is started. This is because we want to postpone 714 // until Shell kicks off a background thread to do the work so that 715 // we do not block the UI thread. 716 if (!in_async_mode_ || async_operation_started_) 717 wait_for_data = true; 718 719 if (!wait_for_data) 720 return DV_E_FORMATETC; 721 722 // Notify the observer we start waiting for the data. This gives 723 // an observer a chance to end the drag and drop. 724 if (observer_) 725 observer_->OnWaitForData(); 726 727 // Now we can start the download. 728 if ((*iter)->downloader.get()) { 729 (*iter)->downloader->Start(this); 730 if (!(*iter)->downloader->Wait()) { 731 is_aborting_ = true; 732 return DV_E_FORMATETC; 733 } 734 } 735 736 // The stored data should have been updated with the final version. 737 // So we just need to call this function again to retrieve it. 738 return GetData(format_etc, medium); 739 } 740 return S_OK; 741 } 742 ++iter; 743 } 744 745 return DV_E_FORMATETC; 746 } 747 748 HRESULT DataObjectImpl::GetDataHere(FORMATETC* format_etc, 749 STGMEDIUM* medium) { 750 return DATA_E_FORMATETC; 751 } 752 753 HRESULT DataObjectImpl::QueryGetData(FORMATETC* format_etc) { 754 StoredData::const_iterator iter = contents_.begin(); 755 while (iter != contents_.end()) { 756 if ((*iter)->format_etc.cfFormat == format_etc->cfFormat) 757 return S_OK; 758 ++iter; 759 } 760 return DV_E_FORMATETC; 761 } 762 763 HRESULT DataObjectImpl::GetCanonicalFormatEtc( 764 FORMATETC* format_etc, FORMATETC* result) { 765 format_etc->ptd = NULL; 766 return E_NOTIMPL; 767 } 768 769 HRESULT DataObjectImpl::SetData( 770 FORMATETC* format_etc, STGMEDIUM* medium, BOOL should_release) { 771 RemoveData(*format_etc); 772 773 STGMEDIUM* local_medium = new STGMEDIUM; 774 if (should_release) { 775 *local_medium = *medium; 776 } else { 777 DuplicateMedium(format_etc->cfFormat, medium, local_medium); 778 } 779 780 DataObjectImpl::StoredDataInfo* info = 781 new DataObjectImpl::StoredDataInfo(*format_etc, local_medium); 782 info->medium->tymed = format_etc->tymed; 783 info->owns_medium = !!should_release; 784 // Make newly added data appear first. 785 // TODO(dcheng): Make various setters agree whether elements should be 786 // prioritized from front to back or back to front. 787 contents_.insert(contents_.begin(), info); 788 789 return S_OK; 790 } 791 792 HRESULT DataObjectImpl::EnumFormatEtc( 793 DWORD direction, IEnumFORMATETC** enumerator) { 794 if (direction == DATADIR_GET) { 795 FormatEtcEnumerator* e = 796 new FormatEtcEnumerator(contents_.begin(), contents_.end()); 797 e->AddRef(); 798 *enumerator = e; 799 return S_OK; 800 } 801 return E_NOTIMPL; 802 } 803 804 HRESULT DataObjectImpl::DAdvise( 805 FORMATETC* format_etc, DWORD advf, IAdviseSink* sink, DWORD* connection) { 806 return OLE_E_ADVISENOTSUPPORTED; 807 } 808 809 HRESULT DataObjectImpl::DUnadvise(DWORD connection) { 810 return OLE_E_ADVISENOTSUPPORTED; 811 } 812 813 HRESULT DataObjectImpl::EnumDAdvise(IEnumSTATDATA** enumerator) { 814 return OLE_E_ADVISENOTSUPPORTED; 815 } 816 817 /////////////////////////////////////////////////////////////////////////////// 818 // DataObjectImpl, IDataObjectAsyncCapability implementation: 819 820 HRESULT DataObjectImpl::EndOperation( 821 HRESULT result, IBindCtx* reserved, DWORD effects) { 822 async_operation_started_ = false; 823 return S_OK; 824 } 825 826 HRESULT DataObjectImpl::GetAsyncMode(BOOL* is_op_async) { 827 *is_op_async = in_async_mode_ ? TRUE : FALSE; 828 return S_OK; 829 } 830 831 HRESULT DataObjectImpl::InOperation(BOOL* in_async_op) { 832 *in_async_op = async_operation_started_ ? TRUE : FALSE; 833 return S_OK; 834 } 835 836 HRESULT DataObjectImpl::SetAsyncMode(BOOL do_op_async) { 837 in_async_mode_ = (do_op_async == TRUE); 838 return S_OK; 839 } 840 841 HRESULT DataObjectImpl::StartOperation(IBindCtx* reserved) { 842 async_operation_started_ = true; 843 return S_OK; 844 } 845 846 /////////////////////////////////////////////////////////////////////////////// 847 // DataObjectImpl, IUnknown implementation: 848 849 HRESULT DataObjectImpl::QueryInterface(const IID& iid, void** object) { 850 if (!object) 851 return E_POINTER; 852 if (IsEqualIID(iid, IID_IDataObject) || IsEqualIID(iid, IID_IUnknown)) { 853 *object = static_cast<IDataObject*>(this); 854 } else if (in_async_mode_ && 855 IsEqualIID(iid, __uuidof(IDataObjectAsyncCapability))) { 856 *object = static_cast<IDataObjectAsyncCapability*>(this); 857 } else { 858 *object = NULL; 859 return E_NOINTERFACE; 860 } 861 AddRef(); 862 return S_OK; 863 } 864 865 ULONG DataObjectImpl::AddRef() { 866 base::RefCountedThreadSafe<DownloadFileObserver>::AddRef(); 867 return 0; 868 } 869 870 ULONG DataObjectImpl::Release() { 871 base::RefCountedThreadSafe<DownloadFileObserver>::Release(); 872 return 0; 873 } 874 875 /////////////////////////////////////////////////////////////////////////////// 876 // DataObjectImpl, private: 877 878 static STGMEDIUM* GetStorageForBytes(const void* data, size_t bytes) { 879 HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes)); 880 if (handle) { 881 base::win::ScopedHGlobal<uint8> scoped(handle); 882 memcpy(scoped.get(), data, bytes); 883 } 884 885 STGMEDIUM* storage = new STGMEDIUM; 886 storage->hGlobal = handle; 887 storage->tymed = TYMED_HGLOBAL; 888 storage->pUnkForRelease = NULL; 889 return storage; 890 } 891 892 template <typename T> 893 static STGMEDIUM* GetStorageForString(const std::basic_string<T>& data) { 894 return GetStorageForBytes( 895 data.c_str(), 896 (data.size() + 1) * sizeof(typename std::basic_string<T>::value_type)); 897 } 898 899 static void GetInternetShortcutFileContents(const GURL& url, 900 std::string* data) { 901 DCHECK(data); 902 static const std::string kInternetShortcutFileStart = 903 "[InternetShortcut]\r\nURL="; 904 static const std::string kInternetShortcutFileEnd = 905 "\r\n"; 906 *data = kInternetShortcutFileStart + url.spec() + kInternetShortcutFileEnd; 907 } 908 909 static void CreateValidFileNameFromTitle(const GURL& url, 910 const base::string16& title, 911 base::string16* validated) { 912 if (title.empty()) { 913 if (url.is_valid()) { 914 *validated = net::GetSuggestedFilename(url, "", "", "", "", 915 std::string()); 916 } else { 917 // Nothing else can be done, just use a default. 918 *validated = 919 l10n_util::GetStringUTF16(IDS_APP_UNTITLED_SHORTCUT_FILE_NAME); 920 } 921 } else { 922 *validated = title; 923 file_util::ReplaceIllegalCharactersInPath(validated, '-'); 924 } 925 static const wchar_t extension[] = L".url"; 926 static const size_t max_length = MAX_PATH - arraysize(extension); 927 if (validated->size() > max_length) 928 validated->erase(max_length); 929 *validated += extension; 930 } 931 932 static STGMEDIUM* GetStorageForFileName(const base::FilePath& path) { 933 const size_t kDropSize = sizeof(DROPFILES); 934 const size_t kTotalBytes = 935 kDropSize + (path.value().length() + 2) * sizeof(wchar_t); 936 HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kTotalBytes); 937 938 base::win::ScopedHGlobal<DROPFILES> locked_mem(hdata); 939 DROPFILES* drop_files = locked_mem.get(); 940 drop_files->pFiles = sizeof(DROPFILES); 941 drop_files->fWide = TRUE; 942 wchar_t* data = reinterpret_cast<wchar_t*>( 943 reinterpret_cast<BYTE*>(drop_files) + kDropSize); 944 const size_t copy_size = (path.value().length() + 1) * sizeof(wchar_t); 945 memcpy(data, path.value().c_str(), copy_size); 946 data[path.value().length() + 1] = L'\0'; // Double NULL 947 948 STGMEDIUM* storage = new STGMEDIUM; 949 storage->tymed = TYMED_HGLOBAL; 950 storage->hGlobal = hdata; 951 storage->pUnkForRelease = NULL; 952 return storage; 953 } 954 955 static LPITEMIDLIST PIDLNext(LPITEMIDLIST pidl) { 956 return reinterpret_cast<LPITEMIDLIST>( 957 reinterpret_cast<BYTE*>(pidl) + pidl->mkid.cb); 958 } 959 960 static size_t PIDLSize(LPITEMIDLIST pidl) { 961 size_t s = 0; 962 while (pidl->mkid.cb > 0) { 963 s += pidl->mkid.cb; 964 pidl = PIDLNext(pidl); 965 } 966 // We add 2 because an LPITEMIDLIST is terminated by two NULL bytes. 967 return 2 + s; 968 } 969 970 static LPITEMIDLIST GetNthPIDL(CIDA* cida, int n) { 971 return reinterpret_cast<LPITEMIDLIST>( 972 reinterpret_cast<LPBYTE>(cida) + cida->aoffset[n]); 973 } 974 975 static LPITEMIDLIST GetPidlFromPath(const base::FilePath& path) { 976 LPITEMIDLIST pidl = NULL; 977 LPSHELLFOLDER desktop_folder = NULL; 978 LPWSTR path_str = const_cast<LPWSTR>(path.value().c_str()); 979 980 if (FAILED(SHGetDesktopFolder(&desktop_folder))) 981 return NULL; 982 983 HRESULT hr = desktop_folder->ParseDisplayName( 984 NULL, NULL, path_str, NULL, &pidl, NULL); 985 986 return SUCCEEDED(hr) ? pidl : NULL; 987 } 988 989 static STGMEDIUM* GetIDListStorageForFileName(const base::FilePath& path) { 990 LPITEMIDLIST pidl = GetPidlFromPath(path); 991 if (!pidl) 992 return NULL; 993 994 // When using CFSTR_SHELLIDLIST the hGlobal field of the STGMEDIUM is a 995 // pointer to a CIDA*. A CIDA is a variable length struct that contains a PIDL 996 // count (a UINT), an array of offsets of the following PIDLs (a UINT[]) and 997 // then a series of PIDLs laid out contiguously in memory. A PIDL is 998 // represented by an ITEMIDLIST struct, which contains a single SHITEMID. 999 // Despite only containing a single SHITEMID, ITEMIDLISTs are so-named because 1000 // SHITEMIDs contain their own size and so given one, the next can be found by 1001 // looking at the section of memory after it. The end of a list is indicated 1002 // by two NULL bytes. 1003 // Here we require two PIDLs - the first PIDL is the parent folder and is 1004 // NULL here to indicate that the parent folder is the desktop, and the second 1005 // is the PIDL of |path|. 1006 const size_t kPIDLCountSize = sizeof(UINT); 1007 const size_t kPIDLOffsetsSize = 2 * sizeof(UINT); 1008 const size_t kFirstPIDLOffset = kPIDLCountSize + kPIDLOffsetsSize; 1009 const size_t kFirstPIDLSize = 2; // Empty PIDL - 2 NULL bytes. 1010 const size_t kSecondPIDLSize = PIDLSize(pidl); 1011 const size_t kCIDASize = kFirstPIDLOffset + kFirstPIDLSize + kSecondPIDLSize; 1012 HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kCIDASize); 1013 1014 base::win::ScopedHGlobal<CIDA> locked_mem(hdata); 1015 CIDA* cida = locked_mem.get(); 1016 cida->cidl = 1; // We have one PIDL (not including the 0th root PIDL). 1017 cida->aoffset[0] = kFirstPIDLOffset; 1018 cida->aoffset[1] = kFirstPIDLOffset + kFirstPIDLSize; 1019 LPITEMIDLIST idl = GetNthPIDL(cida, 0); 1020 idl->mkid.cb = 0; 1021 idl->mkid.abID[0] = 0; 1022 idl = GetNthPIDL(cida, 1); 1023 memcpy(idl, pidl, kSecondPIDLSize); 1024 1025 STGMEDIUM* storage = new STGMEDIUM; 1026 storage->tymed = TYMED_HGLOBAL; 1027 storage->hGlobal = hdata; 1028 storage->pUnkForRelease = NULL; 1029 return storage; 1030 } 1031 1032 static STGMEDIUM* GetStorageForFileDescriptor( 1033 const base::FilePath& path) { 1034 base::string16 file_name = path.value(); 1035 DCHECK(!file_name.empty()); 1036 HANDLE hdata = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR)); 1037 base::win::ScopedHGlobal<FILEGROUPDESCRIPTOR> locked_mem(hdata); 1038 1039 FILEGROUPDESCRIPTOR* descriptor = locked_mem.get(); 1040 descriptor->cItems = 1; 1041 descriptor->fgd[0].dwFlags = FD_LINKUI; 1042 wcsncpy_s(descriptor->fgd[0].cFileName, MAX_PATH, file_name.c_str(), 1043 std::min(file_name.size(), static_cast<size_t>(MAX_PATH - 1u))); 1044 1045 STGMEDIUM* storage = new STGMEDIUM; 1046 storage->tymed = TYMED_HGLOBAL; 1047 storage->hGlobal = hdata; 1048 storage->pUnkForRelease = NULL; 1049 return storage; 1050 } 1051 1052 /////////////////////////////////////////////////////////////////////////////// 1053 // OSExchangeData, public: 1054 1055 // static 1056 OSExchangeData::Provider* OSExchangeData::CreateProvider() { 1057 return new OSExchangeDataProviderWin(); 1058 } 1059 1060 } // namespace ui 1061