Home | History | Annotate | Download | only in dragdrop 
      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