ui/base/dragdrop/os_exchange_data_provider_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "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 "net/base/filename_util.h"
  17 #include "ui/base/clipboard/clipboard.h"
  18 #include "ui/base/clipboard/clipboard_util_win.h"
  19 #include "ui/base/dragdrop/file_info.h"
  20 #include "ui/base/l10n/l10n_util.h"
  21 #include "ui/strings/grit/ui_strings.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_.get(), 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_.get(), url, title,
 414       policy == OSExchangeData::CONVERT_FILENAMES ? true : false);
 415   if (success) {
 416     DCHECK(url->is_valid());
 417     return true;
 418   } else if (GetPlainTextURL(source_object_.get(), url)) {
 419     if (url->is_valid())
 420       *title = net::GetSuggestedFilename(*url, "", "", "", "", std::string());
 421     else
 422       title->clear();
 423     return true;
 424   }
 425   return false;
 426 }
 427
 428 bool OSExchangeDataProviderWin::GetFilename(base::FilePath* path) const {
 429   std::vector<base::string16> filenames;
 430   bool success = ClipboardUtil::GetFilenames(source_object_.get(), &filenames);
 431   if (success)
 432     *path = base::FilePath(filenames[0]);
 433   return success;
 434 }
 435
 436 bool OSExchangeDataProviderWin::GetFilenames(
 437     std::vector<FileInfo>* filenames) const {
 438   std::vector<base::string16> filenames_local;
 439   bool success =
 440       ClipboardUtil::GetFilenames(source_object_.get(), &filenames_local);
 441   if (success) {
 442     for (size_t i = 0; i < filenames_local.size(); ++i)
 443       filenames->push_back(
 444           FileInfo(base::FilePath(filenames_local[i]), base::FilePath()));
 445   }
 446   return success;
 447 }
 448
 449 bool OSExchangeDataProviderWin::GetPickledData(
 450     const OSExchangeData::CustomFormat& format,
 451     Pickle* data) const {
 452   DCHECK(data);
 453   bool success = false;
 454   STGMEDIUM medium;
 455   FORMATETC format_etc = format.ToFormatEtc();
 456   if (SUCCEEDED(source_object_->GetData(&format_etc, &medium))) {
 457     if (medium.tymed & TYMED_HGLOBAL) {
 458       base::win::ScopedHGlobal<char*> c_data(medium.hGlobal);
 459       DCHECK_GT(c_data.Size(), 0u);
 460       *data = Pickle(c_data.get(), static_cast<int>(c_data.Size()));
 461       success = true;
 462     }
 463     ReleaseStgMedium(&medium);
 464   }
 465   return success;
 466 }
 467
 468 bool OSExchangeDataProviderWin::GetFileContents(
 469     base::FilePath* filename,
 470     std::string* file_contents) const {
 471   base::string16 filename_str;
 472   if (!ClipboardUtil::GetFileContents(source_object_.get(), &filename_str,
 473                                       file_contents)) {
 474     return false;
 475   }
 476   *filename = base::FilePath(filename_str);
 477   return true;
 478 }
 479
 480 bool OSExchangeDataProviderWin::GetHtml(base::string16* html,
 481                                         GURL* base_url) const {
 482   std::string url;
 483   bool success = ClipboardUtil::GetHtml(source_object_.get(), html, &url);
 484   if (success)
 485     *base_url = GURL(url);
 486   return success;
 487 }
 488
 489 bool OSExchangeDataProviderWin::HasString() const {
 490   return ClipboardUtil::HasPlainText(source_object_.get());
 491 }
 492
 493 bool OSExchangeDataProviderWin::HasURL(
 494     OSExchangeData::FilenameToURLPolicy policy) const {
 495   return (ClipboardUtil::HasUrl(
 496               source_object_.get(),
 497               policy == OSExchangeData::CONVERT_FILENAMES ? true : false) ||
 498           HasPlainTextURL(source_object_.get()));
 499 }
 500
 501 bool OSExchangeDataProviderWin::HasFile() const {
 502   return ClipboardUtil::HasFilenames(source_object_.get());
 503 }
 504
 505 bool OSExchangeDataProviderWin::HasFileContents() const {
 506   return ClipboardUtil::HasFileContents(source_object_.get());
 507 }
 508
 509 bool OSExchangeDataProviderWin::HasHtml() const {
 510   return ClipboardUtil::HasHtml(source_object_.get());
 511 }
 512
 513 bool OSExchangeDataProviderWin::HasCustomFormat(
 514     const OSExchangeData::CustomFormat& format) const {
 515   FORMATETC format_etc = format.ToFormatEtc();
 516   return (source_object_->QueryGetData(&format_etc) == S_OK);
 517 }
 518
 519 void OSExchangeDataProviderWin::SetDownloadFileInfo(
 520     const OSExchangeData::DownloadFileInfo& download) {
 521   // If the filename is not provided, set storage to NULL to indicate that
 522   // the delay rendering will be used.
 523   // TODO(dcheng): Is it actually possible for filename to be empty here? I
 524   // think we always synthesize one in WebContentsDragWin.
 525   STGMEDIUM* storage = NULL;
 526   if (!download.filename.empty())
 527     storage = GetStorageForFileName(download.filename);
 528
 529   // Add CF_HDROP.
 530   DataObjectImpl::StoredDataInfo* info = new DataObjectImpl::StoredDataInfo(
 531       Clipboard::GetCFHDropFormatType().ToFormatEtc(), storage);
 532   info->downloader = download.downloader;
 533   data_->contents_.push_back(info);
 534 }
 535
 536 void OSExchangeDataProviderWin::SetDragImage(
 537     const gfx::ImageSkia& image,
 538     const gfx::Vector2d& cursor_offset) {
 539   drag_image_ = image;
 540   drag_image_offset_ = cursor_offset;
 541 }
 542
 543 const gfx::ImageSkia& OSExchangeDataProviderWin::GetDragImage() const {
 544   return drag_image_;
 545 }
 546
 547 const gfx::Vector2d& OSExchangeDataProviderWin::GetDragImageOffset() const {
 548   return drag_image_offset_;
 549 }
 550
 551 ///////////////////////////////////////////////////////////////////////////////
 552 // DataObjectImpl, IDataObject implementation:
 553
 554 // The following function, DuplicateMedium, is derived from WCDataObject.cpp
 555 // in the WebKit source code. This is the license information for the file:
 556 /*
 557  * Copyright (C) 2007 Apple Inc.  All rights reserved.
 558  *
 559  * Redistribution and use in source and binary forms, with or without
 560  * modification, are permitted provided that the following conditions
 561  * are met:
 562  * 1. Redistributions of source code must retain the above copyright
 563  *    notice, this list of conditions and the following disclaimer.
 564  * 2. Redistributions in binary form must reproduce the above copyright
 565  *    notice, this list of conditions and the following disclaimer in the
 566  *    documentation and/or other materials provided with the distribution.
 567  *
 568  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 569  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 570  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 571  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 572  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 573  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 574  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 575  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 576  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 577  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 578  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 579  */
 580 static void DuplicateMedium(CLIPFORMAT source_clipformat,
 581                             STGMEDIUM* source,
 582                             STGMEDIUM* destination) {
 583   switch (source->tymed) {
 584     case TYMED_HGLOBAL:
 585       destination->hGlobal =
 586           static_cast<HGLOBAL>(OleDuplicateData(
 587               source->hGlobal, source_clipformat, 0));
 588       break;
 589     case TYMED_MFPICT:
 590       destination->hMetaFilePict =
 591           static_cast<HMETAFILEPICT>(OleDuplicateData(
 592               source->hMetaFilePict, source_clipformat, 0));
 593       break;
 594     case TYMED_GDI:
 595       destination->hBitmap =
 596           static_cast<HBITMAP>(OleDuplicateData(
 597               source->hBitmap, source_clipformat, 0));
 598       break;
 599     case TYMED_ENHMF:
 600       destination->hEnhMetaFile =
 601           static_cast<HENHMETAFILE>(OleDuplicateData(
 602               source->hEnhMetaFile, source_clipformat, 0));
 603       break;
 604     case TYMED_FILE:
 605       destination->lpszFileName =
 606           static_cast<LPOLESTR>(OleDuplicateData(
 607               source->lpszFileName, source_clipformat, 0));
 608       break;
 609     case TYMED_ISTREAM:
 610       destination->pstm = source->pstm;
 611       destination->pstm->AddRef();
 612       break;
 613     case TYMED_ISTORAGE:
 614       destination->pstg = source->pstg;
 615       destination->pstg->AddRef();
 616       break;
 617   }
 618
 619   destination->tymed = source->tymed;
 620   destination->pUnkForRelease = source->pUnkForRelease;
 621   if (destination->pUnkForRelease)
 622     destination->pUnkForRelease->AddRef();
 623 }
 624
 625 DataObjectImpl::DataObjectImpl()
 626     : is_aborting_(false),
 627       in_drag_loop_(false),
 628       in_async_mode_(false),
 629       async_operation_started_(false),
 630       observer_(NULL) {
 631 }
 632
 633 DataObjectImpl::~DataObjectImpl() {
 634   StopDownloads();
 635   if (observer_)
 636     observer_->OnDataObjectDisposed();
 637 }
 638
 639 void DataObjectImpl::StopDownloads() {
 640   for (StoredData::iterator iter = contents_.begin();
 641        iter != contents_.end(); ++iter) {
 642     if ((*iter)->downloader.get()) {
 643       (*iter)->downloader->Stop();
 644       (*iter)->downloader = 0;
 645     }
 646   }
 647 }
 648
 649 void DataObjectImpl::RemoveData(const FORMATETC& format) {
 650   if (format.ptd)
 651     return;  // Don't attempt to compare target devices.
 652
 653   for (StoredData::iterator i = contents_.begin(); i != contents_.end(); ++i) {
 654     if (!(*i)->format_etc.ptd &&
 655         format.cfFormat == (*i)->format_etc.cfFormat &&
 656         format.dwAspect == (*i)->format_etc.dwAspect &&
 657         format.lindex == (*i)->format_etc.lindex &&
 658         format.tymed == (*i)->format_etc.tymed) {
 659       contents_.erase(i);
 660       return;
 661     }
 662   }
 663 }
 664
 665 void DataObjectImpl::OnDownloadCompleted(const base::FilePath& file_path) {
 666   DataObjectImpl::StoredData::iterator iter = contents_.begin();
 667   for (; iter != contents_.end(); ++iter) {
 668     if ((*iter)->format_etc.cfFormat == CF_HDROP) {
 669       // Release the old storage.
 670       if ((*iter)->owns_medium) {
 671         ReleaseStgMedium((*iter)->medium);
 672         delete (*iter)->medium;
 673       }
 674
 675       // Update the storage.
 676       (*iter)->owns_medium = true;
 677       (*iter)->medium = GetStorageForFileName(file_path);
 678
 679       break;
 680     }
 681   }
 682   DCHECK(iter != contents_.end());
 683 }
 684
 685 void DataObjectImpl::OnDownloadAborted() {
 686 }
 687
 688 HRESULT DataObjectImpl::GetData(FORMATETC* format_etc, STGMEDIUM* medium) {
 689   if (is_aborting_)
 690     return DV_E_FORMATETC;
 691
 692   StoredData::iterator iter = contents_.begin();
 693   while (iter != contents_.end()) {
 694     if ((*iter)->format_etc.cfFormat == format_etc->cfFormat &&
 695         (*iter)->format_etc.lindex == format_etc->lindex &&
 696         ((*iter)->format_etc.tymed & format_etc->tymed)) {
 697       // If medium is NULL, delay-rendering will be used.
 698       if ((*iter)->medium) {
 699         DuplicateMedium((*iter)->format_etc.cfFormat, (*iter)->medium, medium);
 700       } else {
 701         // Fail all GetData() attempts for DownloadURL data if the drag and drop
 702         // operation is still in progress.
 703         if (in_drag_loop_)
 704           return DV_E_FORMATETC;
 705
 706         bool wait_for_data = false;
 707
 708         // In async mode, we do not want to start waiting for the data before
 709         // the async operation is started. This is because we want to postpone
 710         // until Shell kicks off a background thread to do the work so that
 711         // we do not block the UI thread.
 712         if (!in_async_mode_ || async_operation_started_)
 713           wait_for_data = true;
 714
 715         if (!wait_for_data)
 716           return DV_E_FORMATETC;
 717
 718         // Notify the observer we start waiting for the data. This gives
 719         // an observer a chance to end the drag and drop.
 720         if (observer_)
 721           observer_->OnWaitForData();
 722
 723         // Now we can start the download.
 724         if ((*iter)->downloader.get()) {
 725           (*iter)->downloader->Start(this);
 726           if (!(*iter)->downloader->Wait()) {
 727             is_aborting_ = true;
 728             return DV_E_FORMATETC;
 729           }
 730         }
 731
 732         // The stored data should have been updated with the final version.
 733         // So we just need to call this function again to retrieve it.
 734         return GetData(format_etc, medium);
 735       }
 736       return S_OK;
 737     }
 738     ++iter;
 739   }
 740
 741   return DV_E_FORMATETC;
 742 }
 743
 744 HRESULT DataObjectImpl::GetDataHere(FORMATETC* format_etc,
 745                                     STGMEDIUM* medium) {
 746   return DATA_E_FORMATETC;
 747 }
 748
 749 HRESULT DataObjectImpl::QueryGetData(FORMATETC* format_etc) {
 750   StoredData::const_iterator iter = contents_.begin();
 751   while (iter != contents_.end()) {
 752     if ((*iter)->format_etc.cfFormat == format_etc->cfFormat)
 753       return S_OK;
 754     ++iter;
 755   }
 756   return DV_E_FORMATETC;
 757 }
 758
 759 HRESULT DataObjectImpl::GetCanonicalFormatEtc(
 760     FORMATETC* format_etc, FORMATETC* result) {
 761   format_etc->ptd = NULL;
 762   return E_NOTIMPL;
 763 }
 764
 765 HRESULT DataObjectImpl::SetData(
 766     FORMATETC* format_etc, STGMEDIUM* medium, BOOL should_release) {
 767   RemoveData(*format_etc);
 768
 769   STGMEDIUM* local_medium = new STGMEDIUM;
 770   if (should_release) {
 771     *local_medium = *medium;
 772   } else {
 773     DuplicateMedium(format_etc->cfFormat, medium, local_medium);
 774   }
 775
 776   DataObjectImpl::StoredDataInfo* info =
 777       new DataObjectImpl::StoredDataInfo(*format_etc, local_medium);
 778   info->medium->tymed = format_etc->tymed;
 779   info->owns_medium = !!should_release;
 780   // Make newly added data appear first.
 781   // TODO(dcheng): Make various setters agree whether elements should be
 782   // prioritized from front to back or back to front.
 783   contents_.insert(contents_.begin(), info);
 784
 785   return S_OK;
 786 }
 787
 788 HRESULT DataObjectImpl::EnumFormatEtc(
 789     DWORD direction, IEnumFORMATETC** enumerator) {
 790   if (direction == DATADIR_GET) {
 791     FormatEtcEnumerator* e =
 792         new FormatEtcEnumerator(contents_.begin(), contents_.end());
 793     e->AddRef();
 794     *enumerator = e;
 795     return S_OK;
 796   }
 797   return E_NOTIMPL;
 798 }
 799
 800 HRESULT DataObjectImpl::DAdvise(
 801     FORMATETC* format_etc, DWORD advf, IAdviseSink* sink, DWORD* connection) {
 802   return OLE_E_ADVISENOTSUPPORTED;
 803 }
 804
 805 HRESULT DataObjectImpl::DUnadvise(DWORD connection) {
 806   return OLE_E_ADVISENOTSUPPORTED;
 807 }
 808
 809 HRESULT DataObjectImpl::EnumDAdvise(IEnumSTATDATA** enumerator) {
 810   return OLE_E_ADVISENOTSUPPORTED;
 811 }
 812
 813 ///////////////////////////////////////////////////////////////////////////////
 814 // DataObjectImpl, IDataObjectAsyncCapability implementation:
 815
 816 HRESULT DataObjectImpl::EndOperation(
 817     HRESULT result, IBindCtx* reserved, DWORD effects) {
 818   async_operation_started_ = false;
 819   return S_OK;
 820 }
 821
 822 HRESULT DataObjectImpl::GetAsyncMode(BOOL* is_op_async) {
 823   *is_op_async = in_async_mode_ ? TRUE : FALSE;
 824   return S_OK;
 825 }
 826
 827 HRESULT DataObjectImpl::InOperation(BOOL* in_async_op) {
 828   *in_async_op = async_operation_started_ ? TRUE : FALSE;
 829   return S_OK;
 830 }
 831
 832 HRESULT DataObjectImpl::SetAsyncMode(BOOL do_op_async) {
 833   in_async_mode_ = (do_op_async == TRUE);
 834   return S_OK;
 835 }
 836
 837 HRESULT DataObjectImpl::StartOperation(IBindCtx* reserved) {
 838   async_operation_started_ = true;
 839   return S_OK;
 840 }
 841
 842 ///////////////////////////////////////////////////////////////////////////////
 843 // DataObjectImpl, IUnknown implementation:
 844
 845 HRESULT DataObjectImpl::QueryInterface(const IID& iid, void** object) {
 846   if (!object)
 847     return E_POINTER;
 848   if (IsEqualIID(iid, IID_IDataObject) || IsEqualIID(iid, IID_IUnknown)) {
 849     *object = static_cast<IDataObject*>(this);
 850   } else if (in_async_mode_ &&
 851              IsEqualIID(iid, __uuidof(IDataObjectAsyncCapability))) {
 852     *object = static_cast<IDataObjectAsyncCapability*>(this);
 853   } else {
 854     *object = NULL;
 855     return E_NOINTERFACE;
 856   }
 857   AddRef();
 858   return S_OK;
 859 }
 860
 861 ULONG DataObjectImpl::AddRef() {
 862   base::RefCountedThreadSafe<DownloadFileObserver>::AddRef();
 863   return 0;
 864 }
 865
 866 ULONG DataObjectImpl::Release() {
 867   base::RefCountedThreadSafe<DownloadFileObserver>::Release();
 868   return 0;
 869 }
 870
 871 ///////////////////////////////////////////////////////////////////////////////
 872 // DataObjectImpl, private:
 873
 874 static STGMEDIUM* GetStorageForBytes(const void* data, size_t bytes) {
 875   HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes));
 876   if (handle) {
 877     base::win::ScopedHGlobal<uint8*> scoped(handle);
 878     memcpy(scoped.get(), data, bytes);
 879   }
 880
 881   STGMEDIUM* storage = new STGMEDIUM;
 882   storage->hGlobal = handle;
 883   storage->tymed = TYMED_HGLOBAL;
 884   storage->pUnkForRelease = NULL;
 885   return storage;
 886 }
 887
 888 template <typename T>
 889 static STGMEDIUM* GetStorageForString(const std::basic_string<T>& data) {
 890   return GetStorageForBytes(
 891       data.c_str(),
 892       (data.size() + 1) * sizeof(typename std::basic_string<T>::value_type));
 893 }
 894
 895 static void GetInternetShortcutFileContents(const GURL& url,
 896                                             std::string* data) {
 897   DCHECK(data);
 898   static const std::string kInternetShortcutFileStart =
 899       "[InternetShortcut]\r\nURL=";
 900   static const std::string kInternetShortcutFileEnd =
 901       "\r\n";
 902   *data = kInternetShortcutFileStart + url.spec() + kInternetShortcutFileEnd;
 903 }
 904
 905 static void CreateValidFileNameFromTitle(const GURL& url,
 906                                          const base::string16& title,
 907                                          base::string16* validated) {
 908   if (title.empty()) {
 909     if (url.is_valid()) {
 910       *validated = net::GetSuggestedFilename(url, "", "", "", "",
 911                                              std::string());
 912     } else {
 913       // Nothing else can be done, just use a default.
 914       *validated =
 915           l10n_util::GetStringUTF16(IDS_APP_UNTITLED_SHORTCUT_FILE_NAME);
 916     }
 917   } else {
 918     *validated = title;
 919     base::i18n::ReplaceIllegalCharactersInPath(validated, '-');
 920   }
 921   static const wchar_t extension[] = L".url";
 922   static const size_t max_length = MAX_PATH - arraysize(extension);
 923   if (validated->size() > max_length)
 924     validated->erase(max_length);
 925   *validated += extension;
 926 }
 927
 928 static STGMEDIUM* GetStorageForFileName(const base::FilePath& path) {
 929   const size_t kDropSize = sizeof(DROPFILES);
 930   const size_t kTotalBytes =
 931       kDropSize + (path.value().length() + 2) * sizeof(wchar_t);
 932   HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kTotalBytes);
 933
 934   base::win::ScopedHGlobal<DROPFILES*> locked_mem(hdata);
 935   DROPFILES* drop_files = locked_mem.get();
 936   drop_files->pFiles = sizeof(DROPFILES);
 937   drop_files->fWide = TRUE;
 938   wchar_t* data = reinterpret_cast<wchar_t*>(
 939       reinterpret_cast<BYTE*>(drop_files) + kDropSize);
 940   const size_t copy_size = (path.value().length() + 1) * sizeof(wchar_t);
 941   memcpy(data, path.value().c_str(), copy_size);
 942   data[path.value().length() + 1] = L'\0';  // Double NULL
 943
 944   STGMEDIUM* storage = new STGMEDIUM;
 945   storage->tymed = TYMED_HGLOBAL;
 946   storage->hGlobal = hdata;
 947   storage->pUnkForRelease = NULL;
 948   return storage;
 949 }
 950
 951 static LPITEMIDLIST PIDLNext(LPITEMIDLIST pidl) {
 952   return reinterpret_cast<LPITEMIDLIST>(
 953       reinterpret_cast<BYTE*>(pidl) + pidl->mkid.cb);
 954 }
 955
 956 static size_t PIDLSize(LPITEMIDLIST pidl) {
 957   size_t s = 0;
 958   while (pidl->mkid.cb > 0) {
 959     s += pidl->mkid.cb;
 960     pidl = PIDLNext(pidl);
 961   }
 962   // We add 2 because an LPITEMIDLIST is terminated by two NULL bytes.
 963   return 2 + s;
 964 }
 965
 966 static LPITEMIDLIST GetNthPIDL(CIDA* cida, int n) {
 967   return reinterpret_cast<LPITEMIDLIST>(
 968       reinterpret_cast<LPBYTE>(cida) + cida->aoffset[n]);
 969 }
 970
 971 static LPITEMIDLIST GetPidlFromPath(const base::FilePath& path) {
 972   LPITEMIDLIST pidl = NULL;
 973   LPSHELLFOLDER desktop_folder = NULL;
 974   LPWSTR path_str = const_cast<LPWSTR>(path.value().c_str());
 975
 976   if (FAILED(SHGetDesktopFolder(&desktop_folder)))
 977     return NULL;
 978
 979   HRESULT hr = desktop_folder->ParseDisplayName(
 980       NULL, NULL, path_str, NULL, &pidl, NULL);
 981
 982   return SUCCEEDED(hr) ? pidl : NULL;
 983 }
 984
 985 static STGMEDIUM* GetIDListStorageForFileName(const base::FilePath& path) {
 986   LPITEMIDLIST pidl = GetPidlFromPath(path);
 987   if (!pidl)
 988     return NULL;
 989
 990   // When using CFSTR_SHELLIDLIST the hGlobal field of the STGMEDIUM is a
 991   // pointer to a CIDA*. A CIDA is a variable length struct that contains a PIDL
 992   // count (a UINT), an array of offsets of the following PIDLs (a UINT[]) and
 993   // then a series of PIDLs laid out contiguously in memory. A PIDL is
 994   // represented by an ITEMIDLIST struct, which contains a single SHITEMID.
 995   // Despite only containing a single SHITEMID, ITEMIDLISTs are so-named because
 996   // SHITEMIDs contain their own size and so given one, the next can be found by
 997   // looking at the section of memory after it. The end of a list is indicated
 998   // by two NULL bytes.
 999   // Here we require two PIDLs - the first PIDL is the parent folder and is
1000   // NULL here to indicate that the parent folder is the desktop, and the second
1001   // is the PIDL of |path|.
1002   const size_t kPIDLCountSize = sizeof(UINT);
1003   const size_t kPIDLOffsetsSize = 2 * sizeof(UINT);
1004   const size_t kFirstPIDLOffset = kPIDLCountSize + kPIDLOffsetsSize;
1005   const size_t kFirstPIDLSize = 2;  // Empty PIDL - 2 NULL bytes.
1006   const size_t kSecondPIDLSize = PIDLSize(pidl);
1007   const size_t kCIDASize = kFirstPIDLOffset + kFirstPIDLSize + kSecondPIDLSize;
1008   HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kCIDASize);
1009
1010   base::win::ScopedHGlobal<CIDA*> locked_mem(hdata);
1011   CIDA* cida = locked_mem.get();
1012   cida->cidl = 1;     // We have one PIDL (not including the 0th root PIDL).
1013   cida->aoffset[0] = kFirstPIDLOffset;
1014   cida->aoffset[1] = kFirstPIDLOffset + kFirstPIDLSize;
1015   LPITEMIDLIST idl = GetNthPIDL(cida, 0);
1016   idl->mkid.cb = 0;
1017   idl->mkid.abID[0] = 0;
1018   idl = GetNthPIDL(cida, 1);
1019   memcpy(idl, pidl, kSecondPIDLSize);
1020
1021   STGMEDIUM* storage = new STGMEDIUM;
1022   storage->tymed = TYMED_HGLOBAL;
1023   storage->hGlobal = hdata;
1024   storage->pUnkForRelease = NULL;
1025   return storage;
1026 }
1027
1028 static STGMEDIUM* GetStorageForFileDescriptor(
1029     const base::FilePath& path) {
1030   base::string16 file_name = path.value();
1031   DCHECK(!file_name.empty());
1032   HANDLE hdata = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));
1033   base::win::ScopedHGlobal<FILEGROUPDESCRIPTOR*> locked_mem(hdata);
1034
1035   FILEGROUPDESCRIPTOR* descriptor = locked_mem.get();
1036   descriptor->cItems = 1;
1037   descriptor->fgd[0].dwFlags = FD_LINKUI;
1038   wcsncpy_s(descriptor->fgd[0].cFileName, MAX_PATH, file_name.c_str(),
1039             std::min(file_name.size(), static_cast<size_t>(MAX_PATH - 1u)));
1040
1041   STGMEDIUM* storage = new STGMEDIUM;
1042   storage->tymed = TYMED_HGLOBAL;
1043   storage->hGlobal = hdata;
1044   storage->pUnkForRelease = NULL;
1045   return storage;
1046 }
1047
1048 ///////////////////////////////////////////////////////////////////////////////
1049 // OSExchangeData, public:
1050
1051 // static
1052 OSExchangeData::Provider* OSExchangeData::CreateProvider() {
1053   return new OSExchangeDataProviderWin();
1054 }
1055
1056 }  // namespace ui