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