Support dragging a virtual file out of the browser.

app/os_exchange_data_provider_win.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "app/os_exchange_data_provider_win.h"
 
 #include "app/clipboard/clipboard_util_win.h"
 #include "app/l10n_util.h"
 #include "base/file_path.h"
 #include "base/i18n/file_util_icu.h"
@@ skipping 11 matching lines @@
 // string version does.
 static STGMEDIUM* GetStorageForBytes(const char* data, size_t bytes);
 static STGMEDIUM* GetStorageForWString(const std::wstring& data);
 static STGMEDIUM* GetStorageForString(const std::string& data);
 // Creates the contents of an Internet Shortcut file for the given URL.
 static void GetInternetShortcutFileContents(const GURL& url, std::string* data);
 // Creates a valid file name given a suggested title and URL.
 static void CreateValidFileNameFromTitle(const GURL& url,
                                          const std::wstring& title,
                                          std::wstring* validated);
+// Creates a new STGMEDIUM object to hold a file.
+static STGMEDIUM* GetStorageForFileName(const std::wstring& full_path);
 // Creates a File Descriptor for the creation of a file to the given URL and
 // returns a handle to it.
 static STGMEDIUM* GetStorageForFileDescriptor(
     const std::wstring& valid_file_name);
 
 ///////////////////////////////////////////////////////////////////////////////
 // FormatEtcEnumerator
 
 //
 // This object implements an enumeration interface. The existence of an
@@ skipping 177 matching lines @@
     GURL gurl(plain_text);
     if (gurl.is_valid()) {
       *url = gurl;
       return true;
     }
   }
   return false;
 }
 
 // static
+DataObjectImpl* OSExchangeDataProviderWin::GetDataObjectImpl(
+    const OSExchangeData& data) {
+  return static_cast<const OSExchangeDataProviderWin*>(&data.provider())->
+      data_.get();
+}
+
+// static
 IDataObject* OSExchangeDataProviderWin::GetIDataObject(
     const OSExchangeData& data) {
-  return static_cast<const OSExchangeDataProviderWin&>(data.provider()).
+  return static_cast<const OSExchangeDataProviderWin*>(&data.provider())->
       data_object();
 }
 
+// static
+IAsyncOperation* OSExchangeDataProviderWin::GetIAsyncOperation(
+    const OSExchangeData& data) {
+  return static_cast<const OSExchangeDataProviderWin*>(&data.provider())->
+      async_operation();
+}
+
 OSExchangeDataProviderWin::OSExchangeDataProviderWin(IDataObject* source)
     : data_(new DataObjectImpl()),
       source_object_(source) {
 }
 
 OSExchangeDataProviderWin::OSExchangeDataProviderWin()
     : data_(new DataObjectImpl()),
       source_object_(data_.get()) {
 }
 
@@ skipping 48 matching lines @@
   // least preferable).
   storage = GetStorageForWString(UTF8ToWide(url.spec()));
   data_->contents_.push_back(
       new DataObjectImpl::StoredDataInfo(CF_UNICODETEXT, storage));
   storage = GetStorageForString(url.spec());
   data_->contents_.push_back(
       new DataObjectImpl::StoredDataInfo(CF_TEXT, storage));
 }
 
 void OSExchangeDataProviderWin::SetFilename(const std::wstring& full_path) {
-  const size_t drop_size = sizeof(DROPFILES);
-  const size_t bytes = drop_size + (full_path.length() + 2) * sizeof(wchar_t);
-  HANDLE hdata = ::GlobalAlloc(GMEM_MOVEABLE, bytes);
-  if (!hdata)
-    return;
-
-  ScopedHGlobal<DROPFILES> locked_mem(hdata);
-  DROPFILES* drop_files = locked_mem.get();
-  drop_files->pFiles = sizeof(DROPFILES);
-  drop_files->fWide = TRUE;
-  wchar_t* data = reinterpret_cast<wchar_t*>((BYTE*)(drop_files) + drop_size);
-  const size_t copy_size = (full_path.length() + 1) * sizeof(wchar_t);
-  memcpy(data, full_path.c_str(), copy_size);
-  data[full_path.length() + 1] = L'\0';  // Double NULL
-
-  // Set up the STGMEDIUM
-  STGMEDIUM* storage = new STGMEDIUM;
-  storage->tymed = TYMED_HGLOBAL;
-  storage->hGlobal = drop_files;
-  storage->pUnkForRelease = NULL;
-
-  // Set up the StoredDataInfo
+  STGMEDIUM* storage = GetStorageForFileName(full_path);
   DataObjectImpl::StoredDataInfo* info =
       new DataObjectImpl::StoredDataInfo(CF_HDROP, storage);
   data_->contents_.push_back(info);
 }
 
 void OSExchangeDataProviderWin::SetPickledData(CLIPFORMAT format,
                                                const Pickle& data) {
   STGMEDIUM* storage = GetStorageForString(
       std::string(static_cast<const char *>(data.data()),
       static_cast<size_t>(data.size())));
   data_->contents_.push_back(
       new DataObjectImpl::StoredDataInfo(format, storage));
 }
 
 void OSExchangeDataProviderWin::SetFileContents(
     const std::wstring& filename,
     const std::string& file_contents) {
   // Add CFSTR_FILEDESCRIPTOR
   STGMEDIUM* storage = GetStorageForFileDescriptor(filename);
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       ClipboardUtil::GetFileDescriptorFormat()->cfFormat, storage));
 
   // Add CFSTR_FILECONTENTS
   storage = GetStorageForBytes(file_contents.data(), file_contents.length());
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
-      ClipboardUtil::GetFileContentFormatZero()->cfFormat, storage));
+      ClipboardUtil::GetFileContentFormatZero(), storage));
 }
 
 void OSExchangeDataProviderWin::SetHtml(const std::wstring& html,
                                         const GURL& base_url) {
   // Add both MS CF_HTML and text/html format.  CF_HTML should be in utf-8.
   std::string utf8_html = WideToUTF8(html);
   std::string url = base_url.is_valid() ? base_url.spec() : std::string();
 
   std::string cf_html = ClipboardUtil::HtmlToCFHtml(utf8_html, url);
   STGMEDIUM* storage = GetStorageForBytes(cf_html.c_str(), cf_html.size());
@@ skipping 91 matching lines @@
 bool OSExchangeDataProviderWin::HasHtml() const {
   return ClipboardUtil::HasHtml(source_object_);
 }
 
 bool OSExchangeDataProviderWin::HasCustomFormat(CLIPFORMAT format) const {
   FORMATETC format_etc =
       { format, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
   return (source_object_->QueryGetData(&format_etc) == S_OK);
 }
 
+void OSExchangeDataProviderWin::SetDownloadFileInfo(
+    OSExchangeData::DownloadFileInfo* download) {
+  // If the filename is not provided, set stoarge to NULL to indicate that
+  // the delay rendering will be used.
+  STGMEDIUM* storage = NULL;
+  if (!download->filename.empty())
+    storage = GetStorageForFileName(download->filename.value());
+
+  // Add CF_HDROP.
+  DataObjectImpl::StoredDataInfo* info = new DataObjectImpl::StoredDataInfo(
+      ClipboardUtil::GetCFHDropFormat()->cfFormat, storage);
+  info->downloads.push_back(download);
+  data_->contents_.push_back(info);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // DataObjectImpl, IDataObject implementation:
 
 // The following function, DuplicateMedium, is derived from WCDataObject.cpp
 // in the WebKit source code. This is the license information for the file:
 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 54 matching lines @@
       destination->pstg->AddRef();
       break;
   }
 
   destination->tymed = source->tymed;
   destination->pUnkForRelease = source->pUnkForRelease;
   if (destination->pUnkForRelease)
     destination->pUnkForRelease->AddRef();
 }
 
-DataObjectImpl::DataObjectImpl() : ref_count_(0) {
-  STLDeleteContainerPointers(contents_.begin(), contents_.end());
+DataObjectImpl::DataObjectImpl()
+    : is_aborting_(false),
+      in_async_mode_(false),
+      async_operation_started_(false),
+      observer_(NULL) {
 }
 
 DataObjectImpl::~DataObjectImpl() {
+  StopDownloads();
   STLDeleteContainerPointers(contents_.begin(), contents_.end());
+  if (observer_)
+    observer_->OnDataObjectDisposed();
+}
+
+void DataObjectImpl::StopDownloads() {
+  for (StoredData::iterator iter = contents_.begin();
+       iter != contents_.end(); ++iter) {
+    for (size_t i = 0; i < (*iter)->downloads.size(); ++i) {
+      if ((*iter)->downloads[i]->downloader) {
+        (*iter)->downloads[i]->downloader->Stop();
+        (*iter)->downloads[i]->downloader = 0;
+      }
+      delete (*iter)->downloads[i];
+    }
+    (*iter)->downloads.clear();
+  }
+}
+
+void DataObjectImpl::OnDataReady(
+    int format,
+    const std::vector<OSExchangeData::DownloadFileInfo*>& downloads) {
+  // Find and update the data corresponding to the format.
+  CLIPFORMAT clip_format = static_cast<CLIPFORMAT>(format);
+  DCHECK(clip_format == ClipboardUtil::GetCFHDropFormat()->cfFormat);
+  DataObjectImpl::StoredData::iterator iter = contents_.begin();
+  for (; iter != contents_.end(); ++iter) {
+    if ((*iter)->format_etc.cfFormat == clip_format) {
+      // Update the downloads.
+      DCHECK(downloads.size() == (*iter)->downloads.size());
+      for (size_t i = 0; i < (*iter)->downloads.size(); ++i) {
+        OSExchangeData::DownloadFileInfo* old_download = (*iter)->downloads[i];
+        (*iter)->downloads[i] = downloads[i];
+        (*iter)->downloads[i]->downloader = old_download->downloader;
+        delete old_download;
+      }
+
+      // Release the old storage.
+      if ((*iter)->owns_medium) {
+        ReleaseStgMedium((*iter)->medium);
+        delete (*iter)->medium;
+      }
+
+      // Update the storage.
+      (*iter)->owns_medium = true;
+      (*iter)->medium = GetStorageForFileName(downloads[0]->filename.value());
+
+      break;
+    }
+  }
+  DCHECK(iter != contents_.end());
 }
 
 HRESULT DataObjectImpl::GetData(FORMATETC* format_etc, STGMEDIUM* medium) {
-  StoredData::const_iterator iter = contents_.begin();
+  if (is_aborting_)
+    return DV_E_FORMATETC;
+
+  StoredData::iterator iter = contents_.begin();
   while (iter != contents_.end()) {
-    if ((*iter)->format_etc.cfFormat == format_etc->cfFormat) {
-      DuplicateMedium((*iter)->format_etc.cfFormat, (*iter)->medium, medium);
+    if ((*iter)->format_etc.cfFormat == format_etc->cfFormat &&
+        (*iter)->format_etc.lindex == format_etc->lindex &&
+        ((*iter)->format_etc.tymed & format_etc->tymed)) {
+      // If medium is NULL, delay-rendering will be used.
+      if ((*iter)->medium) {
+        DuplicateMedium((*iter)->format_etc.cfFormat, (*iter)->medium, medium);
+      } else {
+        // Check if the left button is down.
+        bool is_left_button_down = (GetKeyState(VK_LBUTTON) & 0x8000) != 0;
+
+        bool wait_for_data = false;
+        if ((*iter)->in_delay_rendering) {
+          // Make sure the left button is up. Sometimes the drop target, like
+          // Shell, might be too aggresive in calling GetData when the left
+          // button is not released.
+          if (is_left_button_down)
+            return DV_E_FORMATETC;
+
+          wait_for_data = true;
+        } else {
+          // If the left button is up and the target has not requested the data
+          // yet, it probably means that the target does not support delay-
+          // rendering. So instead, we wait for the data.
+          if (is_left_button_down) {
+            (*iter)->in_delay_rendering = true;
+            memset(medium, 0, sizeof(STGMEDIUM));
+          } else {
+            wait_for_data = true;
+          }
+        }
+
+        if (wait_for_data) {
+          // Notify the observer we start waiting for the data. This gives
+          // an observer a chance to end the drag and drop.
+          if (observer_)
+            observer_->OnWaitForData();
+
+          // Now we can start the downloads. Each download will wait till the
+          // necessary data is ready and then return the control.
+          for (size_t i = 0; i < (*iter)->downloads.size(); ++i) {
+            if ((*iter)->downloads[i]->downloader) {
+              if (!(*iter)->downloads[i]->downloader->Start(
+                     this, format_etc->cfFormat)) {
+                // If any of the download fails to start, abort the whole
+                // process.
+                is_aborting_ = true;
+                StopDownloads();
+                return DV_E_FORMATETC;
+              }
+            }
+          }
+
+          // The stored data should have been updated with the final version.
+          // So we just need to call this function again to retrieve it.
+          return GetData(format_etc, medium);
+        }
+      }
       return S_OK;
     }
     ++iter;
   }
 
   return DV_E_FORMATETC;
 }
 
 HRESULT DataObjectImpl::GetDataHere(FORMATETC* format_etc,
                                     STGMEDIUM* medium) {
@@ skipping 53 matching lines @@
 
 HRESULT DataObjectImpl::DUnadvise(DWORD connection) {
   return OLE_E_ADVISENOTSUPPORTED;
 }
 
 HRESULT DataObjectImpl::EnumDAdvise(IEnumSTATDATA** enumerator) {
   return OLE_E_ADVISENOTSUPPORTED;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// DataObjectImpl, IAsyncOperation implementation:
+
+HRESULT DataObjectImpl::EndOperation(
+    HRESULT result, IBindCtx* reserved, DWORD effects) {
+  async_operation_started_ = false;
+  return S_OK;
+}
+
+HRESULT DataObjectImpl::GetAsyncMode(BOOL* is_op_async) {
+  *is_op_async = in_async_mode_ ? TRUE : FALSE;
+  return S_OK;
+}
+
+HRESULT DataObjectImpl::InOperation(BOOL* in_async_op) {
+  *in_async_op = async_operation_started_ ? TRUE : FALSE;
+  return S_OK;
+}
+
+HRESULT DataObjectImpl::SetAsyncMode(BOOL do_op_async) {
+  in_async_mode_ = (do_op_async == TRUE);
+  return S_OK;
+}
+
+HRESULT DataObjectImpl::StartOperation(IBindCtx* reserved) {
+  async_operation_started_ = true;
+  return S_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // DataObjectImpl, IUnknown implementation:
 
 HRESULT DataObjectImpl::QueryInterface(const IID& iid, void** object) {
-  *object = NULL;
-  if (IsEqualIID(iid, IID_IUnknown) || IsEqualIID(iid, IID_IDataObject)) {
-    *object = this;
+  if (!object)
+    return E_POINTER;
+  if (IsEqualIID(iid, IID_IDataObject) || IsEqualIID(iid, IID_IUnknown)) {
+    *object = static_cast<IDataObject*>(this);
+  } else if (in_async_mode_ && IsEqualIID(iid, IID_IAsyncOperation)) {
+    *object = static_cast<IAsyncOperation*>(this);
   } else {
+    *object = NULL;
     return E_NOINTERFACE;
   }
   AddRef();
   return S_OK;
 }
 
 ULONG DataObjectImpl::AddRef() {
-  return InterlockedIncrement(&ref_count_);
+  base::RefCounted<OSExchangeData::DownloadFileObserver>::AddRef();
+  return 0;
 }
 
 ULONG DataObjectImpl::Release() {
-  if (InterlockedDecrement(&ref_count_) == 0) {
-    ULONG copied_refcnt = ref_count_;
-    delete this;
-    return copied_refcnt;
-  }
-  return ref_count_;
+  base::RefCounted<OSExchangeData::DownloadFileObserver>::Release();
+  return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DataObjectImpl, private:
 
 static STGMEDIUM* GetStorageForBytes(const char* data, size_t bytes) {
   HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes));
   ScopedHGlobal<char> scoped(handle);
   size_t allocated = static_cast<size_t>(GlobalSize(handle));
   memcpy(scoped.get(), data, allocated);
@@ skipping 58 matching lines @@
     *validated = title;
     file_util::ReplaceIllegalCharactersInPath(validated, '-');
   }
   static const wchar_t extension[] = L".url";
   static const size_t max_length = MAX_PATH - arraysize(extension);
   if (validated->size() > max_length)
     validated->erase(max_length);
   *validated += extension;
 }
 
+static STGMEDIUM* GetStorageForFileName(const std::wstring& full_path) {
+  const size_t kDropSize = sizeof(DROPFILES);
+  const size_t kTotalBytes =
+      kDropSize + (full_path.length() + 2) * sizeof(wchar_t);
+  HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kTotalBytes);
+
+  ScopedHGlobal<DROPFILES> locked_mem(hdata);
+  DROPFILES* drop_files = locked_mem.get();
+  drop_files->pFiles = sizeof(DROPFILES);
+  drop_files->fWide = TRUE;
+  wchar_t* data = reinterpret_cast<wchar_t*>(
+      reinterpret_cast<BYTE*>(drop_files) + kDropSize);
+  const size_t copy_size = (full_path.length() + 1) * sizeof(wchar_t);
+  memcpy(data, full_path.c_str(), copy_size);
+  data[full_path.length() + 1] = L'\0';  // Double NULL
+
+  STGMEDIUM* storage = new STGMEDIUM;
+  storage->tymed = TYMED_HGLOBAL;
+  storage->hGlobal = drop_files;
+  storage->pUnkForRelease = NULL;
+  return storage;
+}
+
 static STGMEDIUM* GetStorageForFileDescriptor(
     const std::wstring& valid_file_name) {
   DCHECK(!valid_file_name.empty() && valid_file_name.size() + 1 <= MAX_PATH);
   HANDLE handle = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));
   FILEGROUPDESCRIPTOR* descriptor =
       reinterpret_cast<FILEGROUPDESCRIPTOR*>(GlobalLock(handle));
 
   descriptor->cItems = 1;
   wcscpy_s(descriptor->fgd[0].cFileName,
            valid_file_name.size() + 1,
@@ skipping 15 matching lines @@
 // static
 OSExchangeData::Provider* OSExchangeData::CreateProvider() {
   return new OSExchangeDataProviderWin();
 }
 
 // static
 OSExchangeData::CustomFormat OSExchangeData::RegisterCustomFormat(
     const std::string& type) {
   return RegisterClipboardFormat(ASCIIToWide(type).c_str());
 }