src/tests/cefclient/browser/osr_dragdrop_win.cc - cef - Git at Google

 // Copyright (c) 2014 The Chromium Embedded Framework 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 "tests/cefclient/browser/osr_dragdrop_win.h"

 #if defined(CEF_USE_ATL)

 #include <shellapi.h>
 #include <shlobj.h>
 #include <windowsx.h>

 #include <algorithm>
 #include <string>

 #include "include/wrapper/cef_helpers.h"
 #include "tests/cefclient/browser/bytes_write_handler.h"
 #include "tests/cefclient/browser/resource.h"
 #include "tests/shared/browser/util_win.h"

 namespace client {

 namespace {

 DWORD DragOperationToDropEffect(CefRenderHandler::DragOperation allowed_ops) {
   DWORD effect = DROPEFFECT_NONE;
   if (allowed_ops & DRAG_OPERATION_COPY)
     effect |= DROPEFFECT_COPY;
   if (allowed_ops & DRAG_OPERATION_LINK)
     effect |= DROPEFFECT_LINK;
   if (allowed_ops & DRAG_OPERATION_MOVE)
     effect |= DROPEFFECT_MOVE;
   return effect;
 }

 CefRenderHandler::DragOperationsMask DropEffectToDragOperation(DWORD effect) {
   DWORD operation = DRAG_OPERATION_NONE;
   if (effect & DROPEFFECT_COPY)
     operation |= DRAG_OPERATION_COPY;
   if (effect & DROPEFFECT_LINK)
     operation |= DRAG_OPERATION_LINK;
   if (effect & DROPEFFECT_MOVE)
     operation |= DRAG_OPERATION_MOVE;
   return static_cast<CefRenderHandler::DragOperationsMask>(operation);
 }

 CefMouseEvent ToMouseEvent(POINTL p, DWORD key_state, HWND hWnd) {
   CefMouseEvent ev;
   POINT screen_point = {p.x, p.y};
   ScreenToClient(hWnd, &screen_point);
   ev.x = screen_point.x;
   ev.y = screen_point.y;
   ev.modifiers = GetCefMouseModifiers(key_state);
   return ev;
 }

 void GetStorageForBytes(STGMEDIUM* storage, const void* data, size_t bytes) {
   HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes));
   if (handle) {
     memcpy(handle, data, bytes);
   }

   storage->hGlobal = handle;
   storage->tymed = TYMED_HGLOBAL;
   storage->pUnkForRelease = NULL;
 }

 template <typename T>
 void GetStorageForString(STGMEDIUM* stgmed, const std::basic_string<T>& data) {
   GetStorageForBytes(
       stgmed, data.c_str(),
       (data.size() + 1) * sizeof(typename std::basic_string<T>::value_type));
 }

 void GetStorageForFileDescriptor(STGMEDIUM* storage,
                                  const std::wstring& file_name) {
   DCHECK(!file_name.empty());
   HANDLE hdata = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));

   FILEGROUPDESCRIPTOR* descriptor =
       reinterpret_cast<FILEGROUPDESCRIPTOR*>(hdata);
   descriptor->cItems = 1;
   descriptor->fgd[0].dwFlags = FD_LINKUI;
   wcsncpy_s(descriptor->fgd[0].cFileName, MAX_PATH, file_name.c_str(),
             std::min(file_name.size(), static_cast<size_t>(MAX_PATH - 1u)));

   storage->tymed = TYMED_HGLOBAL;
   storage->hGlobal = hdata;
   storage->pUnkForRelease = NULL;
 }

 // Helper method for converting from text/html to MS CF_HTML.
 // Documentation for the CF_HTML format is available at
 // http://msdn.microsoft.com/en-us/library/aa767917(VS.85).aspx
 std::string HtmlToCFHtml(const std::string& html, const std::string& base_url) {
   if (html.empty())
     return std::string();

 #define MAX_DIGITS 10
 #define MAKE_NUMBER_FORMAT_1(digits) MAKE_NUMBER_FORMAT_2(digits)
 #define MAKE_NUMBER_FORMAT_2(digits) "%0" #digits "u"
 #define NUMBER_FORMAT MAKE_NUMBER_FORMAT_1(MAX_DIGITS)

   static const char* header =
       "Version:0.9\r\n"
       "StartHTML:" NUMBER_FORMAT
       "\r\n"
       "EndHTML:" NUMBER_FORMAT
       "\r\n"
       "StartFragment:" NUMBER_FORMAT
       "\r\n"
       "EndFragment:" NUMBER_FORMAT "\r\n";
   static const char* source_url_prefix = "SourceURL:";

   static const char* start_markup = "<html>\r\n<body>\r\n<!--StartFragment-->";
   static const char* end_markup = "<!--EndFragment-->\r\n</body>\r\n</html>";

   // Calculate offsets
   size_t start_html_offset =
       strlen(header) - strlen(NUMBER_FORMAT) * 4 + MAX_DIGITS * 4;
   if (!base_url.empty()) {
     start_html_offset +=
         strlen(source_url_prefix) + base_url.length() + 2;  // Add 2 for \r\n.
   }
   size_t start_fragment_offset = start_html_offset + strlen(start_markup);
   size_t end_fragment_offset = start_fragment_offset + html.length();
   size_t end_html_offset = end_fragment_offset + strlen(end_markup);
   char raw_result[1024];
   _snprintf(raw_result, sizeof(1024), header, start_html_offset,
             end_html_offset, start_fragment_offset, end_fragment_offset);
   std::string result = raw_result;
   if (!base_url.empty()) {
     result.append(source_url_prefix);
     result.append(base_url);
     result.append("\r\n");
   }
   result.append(start_markup);
   result.append(html);
   result.append(end_markup);

 #undef MAX_DIGITS
 #undef MAKE_NUMBER_FORMAT_1
 #undef MAKE_NUMBER_FORMAT_2
 #undef NUMBER_FORMAT

   return result;
 }

 void CFHtmlExtractMetadata(const std::string& cf_html,
                            std::string* base_url,
                            size_t* html_start,
                            size_t* fragment_start,
                            size_t* fragment_end) {
   // Obtain base_url if present.
   if (base_url) {
     static std::string src_url_str("SourceURL:");
     size_t line_start = cf_html.find(src_url_str);
     if (line_start != std::string::npos) {
       size_t src_end = cf_html.find("\n", line_start);
       size_t src_start = line_start + src_url_str.length();
       if (src_end != std::string::npos && src_start != std::string::npos) {
         *base_url = cf_html.substr(src_start, src_end - src_start);
       }
     }
   }

   // Find the markup between "<!--StartFragment-->" and "<!--EndFragment-->".
   // If the comments cannot be found, like copying from OpenOffice Writer,
   // we simply fall back to using StartFragment/EndFragment bytecount values
   // to determine the fragment indexes.
   std::string cf_html_lower = cf_html;
   size_t markup_start = cf_html_lower.find("<html", 0);
   if (html_start) {
     *html_start = markup_start;
   }
   size_t tag_start = cf_html.find("<!--StartFragment", markup_start);
   if (tag_start == std::string::npos) {
     static std::string start_fragment_str("StartFragment:");
     size_t start_fragment_start = cf_html.find(start_fragment_str);
     if (start_fragment_start != std::string::npos) {
       *fragment_start =
           static_cast<size_t>(atoi(cf_html.c_str() + start_fragment_start +
                                    start_fragment_str.length()));
     }

     static std::string end_fragment_str("EndFragment:");
     size_t end_fragment_start = cf_html.find(end_fragment_str);
     if (end_fragment_start != std::string::npos) {
       *fragment_end = static_cast<size_t>(atoi(
           cf_html.c_str() + end_fragment_start + end_fragment_str.length()));
     }
   } else {
     *fragment_start = cf_html.find('>', tag_start) + 1;
     size_t tag_end = cf_html.rfind("<!--EndFragment", std::string::npos);
     *fragment_end = cf_html.rfind('<', tag_end);
   }
 }

 void CFHtmlToHtml(const std::string& cf_html,
                   std::string* html,
                   std::string* base_url) {
   size_t frag_start = std::string::npos;
   size_t frag_end = std::string::npos;

   CFHtmlExtractMetadata(cf_html, base_url, NULL, &frag_start, &frag_end);

   if (html && frag_start != std::string::npos &&
       frag_end != std::string::npos) {
     *html = cf_html.substr(frag_start, frag_end - frag_start);
   }
 }

 const DWORD moz_url_format = ::RegisterClipboardFormat(L"text/x-moz-url");
 const DWORD html_format = ::RegisterClipboardFormat(L"HTML Format");
 const DWORD file_desc_format = ::RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
 const DWORD file_contents_format =
     ::RegisterClipboardFormat(CFSTR_FILECONTENTS);

 bool DragDataToDataObject(CefRefPtr<CefDragData> drag_data,
                           IDataObject** data_object) {
   const int kMaxDataObjects = 10;
   FORMATETC fmtetcs[kMaxDataObjects];
   STGMEDIUM stgmeds[kMaxDataObjects];
   FORMATETC fmtetc = {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
   int curr_index = 0;
   CefString text = drag_data->GetFragmentText();
   if (!text.empty()) {
     fmtetc.cfFormat = CF_UNICODETEXT;
     fmtetcs[curr_index] = fmtetc;
     GetStorageForString(&stgmeds[curr_index], text.ToWString());
     curr_index++;
   }
   if (drag_data->IsLink() && !drag_data->GetLinkURL().empty()) {
     std::wstring x_moz_url_str = drag_data->GetLinkURL().ToWString();
     x_moz_url_str += '\n';
     x_moz_url_str += drag_data->GetLinkTitle().ToWString();
     fmtetc.cfFormat = moz_url_format;
     fmtetcs[curr_index] = fmtetc;
     GetStorageForString(&stgmeds[curr_index], x_moz_url_str);
     curr_index++;
   }
   CefString html = drag_data->GetFragmentHtml();
   if (!html.empty()) {
     CefString base_url = drag_data->GetFragmentBaseURL();
     std::string cfhtml = HtmlToCFHtml(html.ToString(), base_url.ToString());
     fmtetc.cfFormat = html_format;
     fmtetcs[curr_index] = fmtetc;
     GetStorageForString(&stgmeds[curr_index], cfhtml);
     curr_index++;
   }

   size_t bufferSize = drag_data->GetFileContents(NULL);
   if (bufferSize) {
     CefRefPtr<BytesWriteHandler> handler = new BytesWriteHandler(bufferSize);
     CefRefPtr<CefStreamWriter> writer =
         CefStreamWriter::CreateForHandler(handler.get());
     drag_data->GetFileContents(writer);
     DCHECK_EQ(handler->GetDataSize(), static_cast<int64>(bufferSize));
     CefString fileName = drag_data->GetFileName();
     GetStorageForFileDescriptor(&stgmeds[curr_index], fileName.ToWString());
     fmtetc.cfFormat = file_desc_format;
     fmtetcs[curr_index] = fmtetc;
     curr_index++;
     GetStorageForBytes(&stgmeds[curr_index], handler->GetData(),
                        handler->GetDataSize());
     fmtetc.cfFormat = file_contents_format;
     fmtetcs[curr_index] = fmtetc;
     curr_index++;
   }
   DCHECK_LT(curr_index, kMaxDataObjects);

   CComPtr<DataObjectWin> obj =
       DataObjectWin::Create(fmtetcs, stgmeds, curr_index);
   (*data_object) = obj.Detach();
   return true;
 }

 CefRefPtr<CefDragData> DataObjectToDragData(IDataObject* data_object) {
   CefRefPtr<CefDragData> drag_data = CefDragData::Create();
   IEnumFORMATETC* enumFormats = nullptr;
   HRESULT res = data_object->EnumFormatEtc(DATADIR_GET, &enumFormats);
   if (res != S_OK)
     return drag_data;
   enumFormats->Reset();
   const int kCelt = 10;

   ULONG celtFetched;
   do {
     celtFetched = kCelt;
     FORMATETC rgelt[kCelt];
     res = enumFormats->Next(kCelt, rgelt, &celtFetched);
     for (unsigned i = 0; i < celtFetched; i++) {
       CLIPFORMAT format = rgelt[i].cfFormat;
       if (!(format == CF_UNICODETEXT || format == CF_TEXT ||
             format == moz_url_format || format == html_format ||
             format == CF_HDROP) ||
           rgelt[i].tymed != TYMED_HGLOBAL)
         continue;
       STGMEDIUM medium;
       if (data_object->GetData(&rgelt[i], &medium) == S_OK) {
         if (!medium.hGlobal) {
           ReleaseStgMedium(&medium);
           continue;
         }
         void* hGlobal = GlobalLock(medium.hGlobal);
         if (!hGlobal) {
           ReleaseStgMedium(&medium);
           continue;
         }
         if (format == CF_UNICODETEXT) {
           CefString text;
           text.FromWString((std::wstring::value_type*)hGlobal);
           drag_data->SetFragmentText(text);
         } else if (format == CF_TEXT) {
           CefString text;
           text.FromString((std::string::value_type*)hGlobal);
           drag_data->SetFragmentText(text);
         } else if (format == moz_url_format) {
           std::wstring html((std::wstring::value_type*)hGlobal);
           size_t pos = html.rfind('\n');
           CefString url(html.substr(0, pos));
           CefString title(html.substr(pos + 1));
           drag_data->SetLinkURL(url);
           drag_data->SetLinkTitle(title);
         } else if (format == html_format) {
           std::string cf_html((std::string::value_type*)hGlobal);
           std::string base_url;
           std::string html;
           CFHtmlToHtml(cf_html, &html, &base_url);
           drag_data->SetFragmentHtml(html);
           drag_data->SetFragmentBaseURL(base_url);
         }
         if (format == CF_HDROP) {
           HDROP hdrop = (HDROP)hGlobal;
           const int kMaxFilenameLen = 4096;
           const unsigned num_files = DragQueryFileW(hdrop, 0xffffffff, 0, 0);
           for (unsigned int x = 0; x < num_files; ++x) {
             wchar_t filename[kMaxFilenameLen];
             if (!DragQueryFileW(hdrop, x, filename, kMaxFilenameLen))
               continue;
             WCHAR* name = wcsrchr(filename, '\\');
             drag_data->AddFile(filename, (name ? name + 1 : filename));
           }
         }
         if (medium.hGlobal)
           GlobalUnlock(medium.hGlobal);
         if (format == CF_HDROP)
           DragFinish((HDROP)hGlobal);
         else
           ReleaseStgMedium(&medium);
       }
     }
   } while (res == S_OK);
   enumFormats->Release();
   return drag_data;
 }

 }  // namespace

 CComPtr<DropTargetWin> DropTargetWin::Create(OsrDragEvents* callback,
                                              HWND hWnd) {
   return CComPtr<DropTargetWin>(new DropTargetWin(callback, hWnd));
 }

 HRESULT DropTargetWin::DragEnter(IDataObject* data_object,
                                  DWORD key_state,
                                  POINTL cursor_position,
                                  DWORD* effect) {
   if (!callback_)
     return E_UNEXPECTED;

   CefRefPtr<CefDragData> drag_data = current_drag_data_;
   if (!drag_data) {
     drag_data = DataObjectToDragData(data_object);
   }
   CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
   CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
   mask = callback_->OnDragEnter(drag_data, ev, mask);
   *effect = DragOperationToDropEffect(mask);
   return S_OK;
 }

 CefBrowserHost::DragOperationsMask DropTargetWin::StartDragging(
     CefRefPtr<CefBrowser> browser,
     CefRefPtr<CefDragData> drag_data,
     CefRenderHandler::DragOperationsMask allowed_ops,
     int x,
     int y) {
   CComPtr<IDataObject> dataObject;
   DWORD resEffect = DROPEFFECT_NONE;
   if (DragDataToDataObject(drag_data, &dataObject)) {
     CComPtr<DropSourceWin> dropSource = DropSourceWin::Create();
     DWORD effect = DragOperationToDropEffect(allowed_ops);
     current_drag_data_ = drag_data->Clone();
     current_drag_data_->ResetFileContents();
     HRESULT res = DoDragDrop(dataObject, dropSource, effect, &resEffect);
     if (res != DRAGDROP_S_DROP)
       resEffect = DROPEFFECT_NONE;
     current_drag_data_ = nullptr;
   }
   return DropEffectToDragOperation(resEffect);
 }

 HRESULT DropTargetWin::DragOver(DWORD key_state,
                                 POINTL cursor_position,
                                 DWORD* effect) {
   if (!callback_)
     return E_UNEXPECTED;
   CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
   CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
   mask = callback_->OnDragOver(ev, mask);
   *effect = DragOperationToDropEffect(mask);
   return S_OK;
 }

 HRESULT DropTargetWin::DragLeave() {
   if (!callback_)
     return E_UNEXPECTED;
   callback_->OnDragLeave();
   return S_OK;
 }

 HRESULT DropTargetWin::Drop(IDataObject* data_object,
                             DWORD key_state,
                             POINTL cursor_position,
                             DWORD* effect) {
   if (!callback_)
     return E_UNEXPECTED;
   CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
   CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
   mask = callback_->OnDrop(ev, mask);
   *effect = DragOperationToDropEffect(mask);
   return S_OK;
 }

 CComPtr<DropSourceWin> DropSourceWin::Create() {
   return CComPtr<DropSourceWin>(new DropSourceWin());
 }

 HRESULT DropSourceWin::GiveFeedback(DWORD dwEffect) {
   return DRAGDROP_S_USEDEFAULTCURSORS;
 }

 HRESULT DropSourceWin::QueryContinueDrag(BOOL fEscapePressed,
                                          DWORD grfKeyState) {
   if (fEscapePressed) {
     return DRAGDROP_S_CANCEL;
   }

   if (!(grfKeyState & MK_LBUTTON)) {
     return DRAGDROP_S_DROP;
   }

   return S_OK;
 }

 HRESULT DragEnumFormatEtc::CreateEnumFormatEtc(
     UINT cfmt,
     FORMATETC* afmt,
     IEnumFORMATETC** ppEnumFormatEtc) {
   if (cfmt == 0 || afmt == 0 || ppEnumFormatEtc == 0)
     return E_INVALIDARG;

   *ppEnumFormatEtc = new DragEnumFormatEtc(afmt, cfmt);

   return (*ppEnumFormatEtc) ? S_OK : E_OUTOFMEMORY;
 }

 HRESULT DragEnumFormatEtc::Next(ULONG celt,
                                 FORMATETC* pFormatEtc,
                                 ULONG* pceltFetched) {
   ULONG copied = 0;

   // copy the FORMATETC structures into the caller's buffer
   while (m_nIndex < m_nNumFormats && copied < celt) {
     DeepCopyFormatEtc(&pFormatEtc[copied], &m_pFormatEtc[m_nIndex]);
     copied++;
     m_nIndex++;
   }

   // store result
   if (pceltFetched != 0)
     *pceltFetched = copied;

   // did we copy all that was requested?
   return (copied == celt) ? S_OK : S_FALSE;
 }
 HRESULT DragEnumFormatEtc::Skip(ULONG celt) {
   m_nIndex += celt;
   return (m_nIndex <= m_nNumFormats) ? S_OK : S_FALSE;
 }
 HRESULT DragEnumFormatEtc::Reset(void) {
   m_nIndex = 0;
   return S_OK;
 }
 HRESULT DragEnumFormatEtc::Clone(IEnumFORMATETC** ppEnumFormatEtc) {
   HRESULT hResult;

   // make a duplicate enumerator
   hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);

   if (hResult == S_OK) {
     // manually set the index state
     reinterpret_cast<DragEnumFormatEtc*>(*ppEnumFormatEtc)->m_nIndex = m_nIndex;
   }

   return hResult;
 }

 DragEnumFormatEtc::DragEnumFormatEtc(FORMATETC* pFormatEtc, int nNumFormats) {
   AddRef();

   m_nIndex = 0;
   m_nNumFormats = nNumFormats;
   m_pFormatEtc = new FORMATETC[nNumFormats];

   // make a new copy of each FORMATETC structure
   for (int i = 0; i < nNumFormats; i++) {
     DeepCopyFormatEtc(&m_pFormatEtc[i], &pFormatEtc[i]);
   }
 }
 DragEnumFormatEtc::~DragEnumFormatEtc() {
   // first free any DVTARGETDEVICE structures
   for (ULONG i = 0; i < m_nNumFormats; i++) {
     if (m_pFormatEtc[i].ptd)
       CoTaskMemFree(m_pFormatEtc[i].ptd);
   }

   // now free the main array
   delete[] m_pFormatEtc;
 }

 void DragEnumFormatEtc::DeepCopyFormatEtc(FORMATETC* dest, FORMATETC* source) {
   // copy the source FORMATETC into dest
   *dest = *source;
   if (source->ptd) {
     // allocate memory for the DVTARGETDEVICE if necessary
     dest->ptd = reinterpret_cast<DVTARGETDEVICE*>(
         CoTaskMemAlloc(sizeof(DVTARGETDEVICE)));

     // copy the contents of the source DVTARGETDEVICE into dest->ptd
     *(dest->ptd) = *(source->ptd);
   }
 }

 CComPtr<DataObjectWin> DataObjectWin::Create(FORMATETC* fmtetc,
                                              STGMEDIUM* stgmed,
                                              int count) {
   return CComPtr<DataObjectWin>(new DataObjectWin(fmtetc, stgmed, count));
 }

 HRESULT DataObjectWin::GetDataHere(FORMATETC* pFormatEtc, STGMEDIUM* pmedium) {
   return E_NOTIMPL;
 }

 HRESULT DataObjectWin::QueryGetData(FORMATETC* pFormatEtc) {
   return (LookupFormatEtc(pFormatEtc) == -1) ? DV_E_FORMATETC : S_OK;
 }

 HRESULT DataObjectWin::GetCanonicalFormatEtc(FORMATETC* pFormatEct,
                                              FORMATETC* pFormatEtcOut) {
   pFormatEtcOut->ptd = NULL;
   return E_NOTIMPL;
 }

 HRESULT DataObjectWin::SetData(FORMATETC* pFormatEtc,
                                STGMEDIUM* pMedium,
                                BOOL fRelease) {
   return E_NOTIMPL;
 }

 HRESULT DataObjectWin::DAdvise(FORMATETC* pFormatEtc,
                                DWORD advf,
                                IAdviseSink*,
                                DWORD*) {
   return E_NOTIMPL;
 }

 HRESULT DataObjectWin::DUnadvise(DWORD dwConnection) {
   return E_NOTIMPL;
 }

 HRESULT DataObjectWin::EnumDAdvise(IEnumSTATDATA** ppEnumAdvise) {
   return E_NOTIMPL;
 }

 HRESULT DataObjectWin::EnumFormatEtc(DWORD dwDirection,
                                      IEnumFORMATETC** ppEnumFormatEtc) {
   return DragEnumFormatEtc::CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc,
                                                 ppEnumFormatEtc);
 }

 HRESULT DataObjectWin::GetData(FORMATETC* pFormatEtc, STGMEDIUM* pMedium) {
   int idx;

   // try to match the specified FORMATETC with one of our supported formats
   if ((idx = LookupFormatEtc(pFormatEtc)) == -1)
     return DV_E_FORMATETC;

   // found a match - transfer data into supplied storage medium
   pMedium->tymed = m_pFormatEtc[idx].tymed;
   pMedium->pUnkForRelease = 0;

   // copy the data into the caller's storage medium
   switch (m_pFormatEtc[idx].tymed) {
     case TYMED_HGLOBAL:
       pMedium->hGlobal = DupGlobalMem(m_pStgMedium[idx].hGlobal);
       break;

     default:
       return DV_E_FORMATETC;
   }
   return S_OK;
 }

 HGLOBAL DataObjectWin::DupGlobalMem(HGLOBAL hMem) {
   DWORD len = GlobalSize(hMem);
   PVOID source = GlobalLock(hMem);
   PVOID dest = GlobalAlloc(GMEM_FIXED, len);

   memcpy(dest, source, len);
   GlobalUnlock(hMem);
   return dest;
 }

 int DataObjectWin::LookupFormatEtc(FORMATETC* pFormatEtc) {
   // check each of our formats in turn to see if one matches
   for (int i = 0; i < m_nNumFormats; i++) {
     if ((m_pFormatEtc[i].tymed & pFormatEtc->tymed) &&
         m_pFormatEtc[i].cfFormat == pFormatEtc->cfFormat &&
         m_pFormatEtc[i].dwAspect == pFormatEtc->dwAspect) {
       // return index of stored format
       return i;
     }
   }

   // error, format not found
   return -1;
 }

 DataObjectWin::DataObjectWin(FORMATETC* fmtetc, STGMEDIUM* stgmed, int count)
     : ref_count_(0) {
   m_nNumFormats = count;

   m_pFormatEtc = new FORMATETC[count];
   m_pStgMedium = new STGMEDIUM[count];

   for (int i = 0; i < count; i++) {
     m_pFormatEtc[i] = fmtetc[i];
     m_pStgMedium[i] = stgmed[i];
   }
 }

 }  // namespace client

 #endif  // defined(CEF_USE_ATL)
	// Copyright (c) 2014 The Chromium Embedded Framework 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 "tests/cefclient/browser/osr_dragdrop_win.h"

	#if defined(CEF_USE_ATL)

	#include <shellapi.h>
	#include <shlobj.h>
	#include <windowsx.h>

	#include <algorithm>
	#include <string>

	#include "include/wrapper/cef_helpers.h"
	#include "tests/cefclient/browser/bytes_write_handler.h"
	#include "tests/cefclient/browser/resource.h"
	#include "tests/shared/browser/util_win.h"

	namespace client {

	namespace {

	DWORD DragOperationToDropEffect(CefRenderHandler::DragOperation allowed_ops) {
	DWORD effect = DROPEFFECT_NONE;
	if (allowed_ops & DRAG_OPERATION_COPY)
	effect \|= DROPEFFECT_COPY;
	if (allowed_ops & DRAG_OPERATION_LINK)
	effect \|= DROPEFFECT_LINK;
	if (allowed_ops & DRAG_OPERATION_MOVE)
	effect \|= DROPEFFECT_MOVE;
	return effect;
	}

	CefRenderHandler::DragOperationsMask DropEffectToDragOperation(DWORD effect) {
	DWORD operation = DRAG_OPERATION_NONE;
	if (effect & DROPEFFECT_COPY)
	operation \|= DRAG_OPERATION_COPY;
	if (effect & DROPEFFECT_LINK)
	operation \|= DRAG_OPERATION_LINK;
	if (effect & DROPEFFECT_MOVE)
	operation \|= DRAG_OPERATION_MOVE;
	return static_cast<CefRenderHandler::DragOperationsMask>(operation);
	}

	CefMouseEvent ToMouseEvent(POINTL p, DWORD key_state, HWND hWnd) {
	CefMouseEvent ev;
	POINT screen_point = {p.x, p.y};
	ScreenToClient(hWnd, &screen_point);
	ev.x = screen_point.x;
	ev.y = screen_point.y;
	ev.modifiers = GetCefMouseModifiers(key_state);
	return ev;
	}

	void GetStorageForBytes(STGMEDIUM* storage, const void* data, size_t bytes) {
	HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes));
	if (handle) {
	memcpy(handle, data, bytes);
	}

	storage->hGlobal = handle;
	storage->tymed = TYMED_HGLOBAL;
	storage->pUnkForRelease = NULL;
	}

	template <typename T>
	void GetStorageForString(STGMEDIUM* stgmed, const std::basic_string<T>& data) {
	GetStorageForBytes(
	stgmed, data.c_str(),
	(data.size() + 1) * sizeof(typename std::basic_string<T>::value_type));
	}

	void GetStorageForFileDescriptor(STGMEDIUM* storage,
	const std::wstring& file_name) {
	DCHECK(!file_name.empty());
	HANDLE hdata = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));

	FILEGROUPDESCRIPTOR* descriptor =
	reinterpret_cast<FILEGROUPDESCRIPTOR*>(hdata);
	descriptor->cItems = 1;
	descriptor->fgd[0].dwFlags = FD_LINKUI;
	wcsncpy_s(descriptor->fgd[0].cFileName, MAX_PATH, file_name.c_str(),
	std::min(file_name.size(), static_cast<size_t>(MAX_PATH - 1u)));

	storage->tymed = TYMED_HGLOBAL;
	storage->hGlobal = hdata;
	storage->pUnkForRelease = NULL;
	}

	// Helper method for converting from text/html to MS CF_HTML.
	// Documentation for the CF_HTML format is available at
	// http://msdn.microsoft.com/en-us/library/aa767917(VS.85).aspx
	std::string HtmlToCFHtml(const std::string& html, const std::string& base_url) {
	if (html.empty())
	return std::string();

	#define MAX_DIGITS 10
	#define MAKE_NUMBER_FORMAT_1(digits) MAKE_NUMBER_FORMAT_2(digits)
	#define MAKE_NUMBER_FORMAT_2(digits) "%0" #digits "u"
	#define NUMBER_FORMAT MAKE_NUMBER_FORMAT_1(MAX_DIGITS)

	static const char* header =
	"Version:0.9\r\n"
	"StartHTML:" NUMBER_FORMAT
	"\r\n"
	"EndHTML:" NUMBER_FORMAT
	"\r\n"
	"StartFragment:" NUMBER_FORMAT
	"\r\n"
	"EndFragment:" NUMBER_FORMAT "\r\n";
	static const char* source_url_prefix = "SourceURL:";

	static const char* start_markup = "<html>\r\n<body>\r\n<!--StartFragment-->";
	static const char* end_markup = "<!--EndFragment-->\r\n</body>\r\n</html>";

	// Calculate offsets
	size_t start_html_offset =
	strlen(header) - strlen(NUMBER_FORMAT) * 4 + MAX_DIGITS * 4;
	if (!base_url.empty()) {
	start_html_offset +=
	strlen(source_url_prefix) + base_url.length() + 2; // Add 2 for \r\n.
	}
	size_t start_fragment_offset = start_html_offset + strlen(start_markup);
	size_t end_fragment_offset = start_fragment_offset + html.length();
	size_t end_html_offset = end_fragment_offset + strlen(end_markup);
	char raw_result[1024];
	_snprintf(raw_result, sizeof(1024), header, start_html_offset,
	end_html_offset, start_fragment_offset, end_fragment_offset);
	std::string result = raw_result;
	if (!base_url.empty()) {
	result.append(source_url_prefix);
	result.append(base_url);
	result.append("\r\n");
	}
	result.append(start_markup);
	result.append(html);
	result.append(end_markup);

	#undef MAX_DIGITS
	#undef MAKE_NUMBER_FORMAT_1
	#undef MAKE_NUMBER_FORMAT_2
	#undef NUMBER_FORMAT

	return result;
	}

	void CFHtmlExtractMetadata(const std::string& cf_html,
	std::string* base_url,
	size_t* html_start,
	size_t* fragment_start,
	size_t* fragment_end) {
	// Obtain base_url if present.
	if (base_url) {
	static std::string src_url_str("SourceURL:");
	size_t line_start = cf_html.find(src_url_str);
	if (line_start != std::string::npos) {
	size_t src_end = cf_html.find("\n", line_start);
	size_t src_start = line_start + src_url_str.length();
	if (src_end != std::string::npos && src_start != std::string::npos) {
	*base_url = cf_html.substr(src_start, src_end - src_start);
	}
	}
	}

	// Find the markup between "<!--StartFragment-->" and "<!--EndFragment-->".
	// If the comments cannot be found, like copying from OpenOffice Writer,
	// we simply fall back to using StartFragment/EndFragment bytecount values
	// to determine the fragment indexes.
	std::string cf_html_lower = cf_html;
	size_t markup_start = cf_html_lower.find("<html", 0);
	if (html_start) {
	*html_start = markup_start;
	}
	size_t tag_start = cf_html.find("<!--StartFragment", markup_start);
	if (tag_start == std::string::npos) {
	static std::string start_fragment_str("StartFragment:");
	size_t start_fragment_start = cf_html.find(start_fragment_str);
	if (start_fragment_start != std::string::npos) {
	*fragment_start =
	static_cast<size_t>(atoi(cf_html.c_str() + start_fragment_start +
	start_fragment_str.length()));
	}

	static std::string end_fragment_str("EndFragment:");
	size_t end_fragment_start = cf_html.find(end_fragment_str);
	if (end_fragment_start != std::string::npos) {
	*fragment_end = static_cast<size_t>(atoi(
	cf_html.c_str() + end_fragment_start + end_fragment_str.length()));
	}
	} else {
	*fragment_start = cf_html.find('>', tag_start) + 1;
	size_t tag_end = cf_html.rfind("<!--EndFragment", std::string::npos);
	*fragment_end = cf_html.rfind('<', tag_end);
	}
	}

	void CFHtmlToHtml(const std::string& cf_html,
	std::string* html,
	std::string* base_url) {
	size_t frag_start = std::string::npos;
	size_t frag_end = std::string::npos;

	CFHtmlExtractMetadata(cf_html, base_url, NULL, &frag_start, &frag_end);

	if (html && frag_start != std::string::npos &&
	frag_end != std::string::npos) {
	*html = cf_html.substr(frag_start, frag_end - frag_start);
	}
	}

	const DWORD moz_url_format = ::RegisterClipboardFormat(L"text/x-moz-url");
	const DWORD html_format = ::RegisterClipboardFormat(L"HTML Format");
	const DWORD file_desc_format = ::RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
	const DWORD file_contents_format =
	::RegisterClipboardFormat(CFSTR_FILECONTENTS);

	bool DragDataToDataObject(CefRefPtr<CefDragData> drag_data,
	IDataObject** data_object) {
	const int kMaxDataObjects = 10;
	FORMATETC fmtetcs[kMaxDataObjects];
	STGMEDIUM stgmeds[kMaxDataObjects];
	FORMATETC fmtetc = {0, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
	int curr_index = 0;
	CefString text = drag_data->GetFragmentText();
	if (!text.empty()) {
	fmtetc.cfFormat = CF_UNICODETEXT;
	fmtetcs[curr_index] = fmtetc;
	GetStorageForString(&stgmeds[curr_index], text.ToWString());
	curr_index++;
	}
	if (drag_data->IsLink() && !drag_data->GetLinkURL().empty()) {
	std::wstring x_moz_url_str = drag_data->GetLinkURL().ToWString();
	x_moz_url_str += '\n';
	x_moz_url_str += drag_data->GetLinkTitle().ToWString();
	fmtetc.cfFormat = moz_url_format;
	fmtetcs[curr_index] = fmtetc;
	GetStorageForString(&stgmeds[curr_index], x_moz_url_str);
	curr_index++;
	}
	CefString html = drag_data->GetFragmentHtml();
	if (!html.empty()) {
	CefString base_url = drag_data->GetFragmentBaseURL();
	std::string cfhtml = HtmlToCFHtml(html.ToString(), base_url.ToString());
	fmtetc.cfFormat = html_format;
	fmtetcs[curr_index] = fmtetc;
	GetStorageForString(&stgmeds[curr_index], cfhtml);
	curr_index++;
	}

	size_t bufferSize = drag_data->GetFileContents(NULL);
	if (bufferSize) {
	CefRefPtr<BytesWriteHandler> handler = new BytesWriteHandler(bufferSize);
	CefRefPtr<CefStreamWriter> writer =
	CefStreamWriter::CreateForHandler(handler.get());
	drag_data->GetFileContents(writer);
	DCHECK_EQ(handler->GetDataSize(), static_cast<int64>(bufferSize));
	CefString fileName = drag_data->GetFileName();
	GetStorageForFileDescriptor(&stgmeds[curr_index], fileName.ToWString());
	fmtetc.cfFormat = file_desc_format;
	fmtetcs[curr_index] = fmtetc;
	curr_index++;
	GetStorageForBytes(&stgmeds[curr_index], handler->GetData(),
	handler->GetDataSize());
	fmtetc.cfFormat = file_contents_format;
	fmtetcs[curr_index] = fmtetc;
	curr_index++;
	}
	DCHECK_LT(curr_index, kMaxDataObjects);

	CComPtr<DataObjectWin> obj =
	DataObjectWin::Create(fmtetcs, stgmeds, curr_index);
	(*data_object) = obj.Detach();
	return true;
	}

	CefRefPtr<CefDragData> DataObjectToDragData(IDataObject* data_object) {
	CefRefPtr<CefDragData> drag_data = CefDragData::Create();
	IEnumFORMATETC* enumFormats = nullptr;
	HRESULT res = data_object->EnumFormatEtc(DATADIR_GET, &enumFormats);
	if (res != S_OK)
	return drag_data;
	enumFormats->Reset();
	const int kCelt = 10;

	ULONG celtFetched;
	do {
	celtFetched = kCelt;
	FORMATETC rgelt[kCelt];
	res = enumFormats->Next(kCelt, rgelt, &celtFetched);
	for (unsigned i = 0; i < celtFetched; i++) {
	CLIPFORMAT format = rgelt[i].cfFormat;
	if (!(format == CF_UNICODETEXT \|\| format == CF_TEXT \|\|
	format == moz_url_format \|\| format == html_format \|\|
	format == CF_HDROP) \|\|
	rgelt[i].tymed != TYMED_HGLOBAL)
	continue;
	STGMEDIUM medium;
	if (data_object->GetData(&rgelt[i], &medium) == S_OK) {
	if (!medium.hGlobal) {
	ReleaseStgMedium(&medium);
	continue;
	}
	void* hGlobal = GlobalLock(medium.hGlobal);
	if (!hGlobal) {
	ReleaseStgMedium(&medium);
	continue;
	}
	if (format == CF_UNICODETEXT) {
	CefString text;
	text.FromWString((std::wstring::value_type*)hGlobal);
	drag_data->SetFragmentText(text);
	} else if (format == CF_TEXT) {
	CefString text;
	text.FromString((std::string::value_type*)hGlobal);
	drag_data->SetFragmentText(text);
	} else if (format == moz_url_format) {
	std::wstring html((std::wstring::value_type*)hGlobal);
	size_t pos = html.rfind('\n');
	CefString url(html.substr(0, pos));
	CefString title(html.substr(pos + 1));
	drag_data->SetLinkURL(url);
	drag_data->SetLinkTitle(title);
	} else if (format == html_format) {
	std::string cf_html((std::string::value_type*)hGlobal);
	std::string base_url;
	std::string html;
	CFHtmlToHtml(cf_html, &html, &base_url);
	drag_data->SetFragmentHtml(html);
	drag_data->SetFragmentBaseURL(base_url);
	}
	if (format == CF_HDROP) {
	HDROP hdrop = (HDROP)hGlobal;
	const int kMaxFilenameLen = 4096;
	const unsigned num_files = DragQueryFileW(hdrop, 0xffffffff, 0, 0);
	for (unsigned int x = 0; x < num_files; ++x) {
	wchar_t filename[kMaxFilenameLen];
	if (!DragQueryFileW(hdrop, x, filename, kMaxFilenameLen))
	continue;
	WCHAR* name = wcsrchr(filename, '\\');
	drag_data->AddFile(filename, (name ? name + 1 : filename));
	}
	}
	if (medium.hGlobal)
	GlobalUnlock(medium.hGlobal);
	if (format == CF_HDROP)
	DragFinish((HDROP)hGlobal);
	else
	ReleaseStgMedium(&medium);
	}
	}
	} while (res == S_OK);
	enumFormats->Release();
	return drag_data;
	}

	} // namespace

	CComPtr<DropTargetWin> DropTargetWin::Create(OsrDragEvents* callback,
	HWND hWnd) {
	return CComPtr<DropTargetWin>(new DropTargetWin(callback, hWnd));
	}

	HRESULT DropTargetWin::DragEnter(IDataObject* data_object,
	DWORD key_state,
	POINTL cursor_position,
	DWORD* effect) {
	if (!callback_)
	return E_UNEXPECTED;

	CefRefPtr<CefDragData> drag_data = current_drag_data_;
	if (!drag_data) {
	drag_data = DataObjectToDragData(data_object);
	}
	CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
	CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
	mask = callback_->OnDragEnter(drag_data, ev, mask);
	*effect = DragOperationToDropEffect(mask);
	return S_OK;
	}

	CefBrowserHost::DragOperationsMask DropTargetWin::StartDragging(
	CefRefPtr<CefBrowser> browser,
	CefRefPtr<CefDragData> drag_data,
	CefRenderHandler::DragOperationsMask allowed_ops,
	int x,
	int y) {
	CComPtr<IDataObject> dataObject;
	DWORD resEffect = DROPEFFECT_NONE;
	if (DragDataToDataObject(drag_data, &dataObject)) {
	CComPtr<DropSourceWin> dropSource = DropSourceWin::Create();
	DWORD effect = DragOperationToDropEffect(allowed_ops);
	current_drag_data_ = drag_data->Clone();
	current_drag_data_->ResetFileContents();
	HRESULT res = DoDragDrop(dataObject, dropSource, effect, &resEffect);
	if (res != DRAGDROP_S_DROP)
	resEffect = DROPEFFECT_NONE;
	current_drag_data_ = nullptr;
	}
	return DropEffectToDragOperation(resEffect);
	}

	HRESULT DropTargetWin::DragOver(DWORD key_state,
	POINTL cursor_position,
	DWORD* effect) {
	if (!callback_)
	return E_UNEXPECTED;
	CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
	CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
	mask = callback_->OnDragOver(ev, mask);
	*effect = DragOperationToDropEffect(mask);
	return S_OK;
	}

	HRESULT DropTargetWin::DragLeave() {
	if (!callback_)
	return E_UNEXPECTED;
	callback_->OnDragLeave();
	return S_OK;
	}

	HRESULT DropTargetWin::Drop(IDataObject* data_object,
	DWORD key_state,
	POINTL cursor_position,
	DWORD* effect) {
	if (!callback_)
	return E_UNEXPECTED;
	CefMouseEvent ev = ToMouseEvent(cursor_position, key_state, hWnd_);
	CefBrowserHost::DragOperationsMask mask = DropEffectToDragOperation(*effect);
	mask = callback_->OnDrop(ev, mask);
	*effect = DragOperationToDropEffect(mask);
	return S_OK;
	}

	CComPtr<DropSourceWin> DropSourceWin::Create() {
	return CComPtr<DropSourceWin>(new DropSourceWin());
	}

	HRESULT DropSourceWin::GiveFeedback(DWORD dwEffect) {
	return DRAGDROP_S_USEDEFAULTCURSORS;
	}

	HRESULT DropSourceWin::QueryContinueDrag(BOOL fEscapePressed,
	DWORD grfKeyState) {
	if (fEscapePressed) {
	return DRAGDROP_S_CANCEL;
	}

	if (!(grfKeyState & MK_LBUTTON)) {
	return DRAGDROP_S_DROP;
	}

	return S_OK;
	}

	HRESULT DragEnumFormatEtc::CreateEnumFormatEtc(
	UINT cfmt,
	FORMATETC* afmt,
	IEnumFORMATETC** ppEnumFormatEtc) {
	if (cfmt == 0 \|\| afmt == 0 \|\| ppEnumFormatEtc == 0)
	return E_INVALIDARG;

	*ppEnumFormatEtc = new DragEnumFormatEtc(afmt, cfmt);

	return (*ppEnumFormatEtc) ? S_OK : E_OUTOFMEMORY;
	}

	HRESULT DragEnumFormatEtc::Next(ULONG celt,
	FORMATETC* pFormatEtc,
	ULONG* pceltFetched) {
	ULONG copied = 0;

	// copy the FORMATETC structures into the caller's buffer
	while (m_nIndex < m_nNumFormats && copied < celt) {
	DeepCopyFormatEtc(&pFormatEtc[copied], &m_pFormatEtc[m_nIndex]);
	copied++;
	m_nIndex++;
	}

	// store result
	if (pceltFetched != 0)
	*pceltFetched = copied;

	// did we copy all that was requested?
	return (copied == celt) ? S_OK : S_FALSE;
	}
	HRESULT DragEnumFormatEtc::Skip(ULONG celt) {
	m_nIndex += celt;
	return (m_nIndex <= m_nNumFormats) ? S_OK : S_FALSE;
	}
	HRESULT DragEnumFormatEtc::Reset(void) {
	m_nIndex = 0;
	return S_OK;
	}
	HRESULT DragEnumFormatEtc::Clone(IEnumFORMATETC** ppEnumFormatEtc) {
	HRESULT hResult;

	// make a duplicate enumerator
	hResult = CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc, ppEnumFormatEtc);

	if (hResult == S_OK) {
	// manually set the index state
	reinterpret_cast<DragEnumFormatEtc>(ppEnumFormatEtc)->m_nIndex = m_nIndex;
	}

	return hResult;
	}

	DragEnumFormatEtc::DragEnumFormatEtc(FORMATETC* pFormatEtc, int nNumFormats) {
	AddRef();

	m_nIndex = 0;
	m_nNumFormats = nNumFormats;
	m_pFormatEtc = new FORMATETC[nNumFormats];

	// make a new copy of each FORMATETC structure
	for (int i = 0; i < nNumFormats; i++) {
	DeepCopyFormatEtc(&m_pFormatEtc[i], &pFormatEtc[i]);
	}
	}
	DragEnumFormatEtc::~DragEnumFormatEtc() {
	// first free any DVTARGETDEVICE structures
	for (ULONG i = 0; i < m_nNumFormats; i++) {
	if (m_pFormatEtc[i].ptd)
	CoTaskMemFree(m_pFormatEtc[i].ptd);
	}

	// now free the main array
	delete[] m_pFormatEtc;
	}

	void DragEnumFormatEtc::DeepCopyFormatEtc(FORMATETC* dest, FORMATETC* source) {
	// copy the source FORMATETC into dest
	dest = source;
	if (source->ptd) {
	// allocate memory for the DVTARGETDEVICE if necessary
	dest->ptd = reinterpret_cast<DVTARGETDEVICE*>(
	CoTaskMemAlloc(sizeof(DVTARGETDEVICE)));

	// copy the contents of the source DVTARGETDEVICE into dest->ptd
	(dest->ptd) = (source->ptd);
	}
	}

	CComPtr<DataObjectWin> DataObjectWin::Create(FORMATETC* fmtetc,
	STGMEDIUM* stgmed,
	int count) {
	return CComPtr<DataObjectWin>(new DataObjectWin(fmtetc, stgmed, count));
	}

	HRESULT DataObjectWin::GetDataHere(FORMATETC* pFormatEtc, STGMEDIUM* pmedium) {
	return E_NOTIMPL;
	}

	HRESULT DataObjectWin::QueryGetData(FORMATETC* pFormatEtc) {
	return (LookupFormatEtc(pFormatEtc) == -1) ? DV_E_FORMATETC : S_OK;
	}

	HRESULT DataObjectWin::GetCanonicalFormatEtc(FORMATETC* pFormatEct,
	FORMATETC* pFormatEtcOut) {
	pFormatEtcOut->ptd = NULL;
	return E_NOTIMPL;
	}

	HRESULT DataObjectWin::SetData(FORMATETC* pFormatEtc,
	STGMEDIUM* pMedium,
	BOOL fRelease) {
	return E_NOTIMPL;
	}

	HRESULT DataObjectWin::DAdvise(FORMATETC* pFormatEtc,
	DWORD advf,
	IAdviseSink*,
	DWORD*) {
	return E_NOTIMPL;
	}

	HRESULT DataObjectWin::DUnadvise(DWORD dwConnection) {
	return E_NOTIMPL;
	}

	HRESULT DataObjectWin::EnumDAdvise(IEnumSTATDATA** ppEnumAdvise) {
	return E_NOTIMPL;
	}

	HRESULT DataObjectWin::EnumFormatEtc(DWORD dwDirection,
	IEnumFORMATETC** ppEnumFormatEtc) {
	return DragEnumFormatEtc::CreateEnumFormatEtc(m_nNumFormats, m_pFormatEtc,
	ppEnumFormatEtc);
	}

	HRESULT DataObjectWin::GetData(FORMATETC* pFormatEtc, STGMEDIUM* pMedium) {
	int idx;

	// try to match the specified FORMATETC with one of our supported formats
	if ((idx = LookupFormatEtc(pFormatEtc)) == -1)
	return DV_E_FORMATETC;

	// found a match - transfer data into supplied storage medium
	pMedium->tymed = m_pFormatEtc[idx].tymed;
	pMedium->pUnkForRelease = 0;

	// copy the data into the caller's storage medium
	switch (m_pFormatEtc[idx].tymed) {
	case TYMED_HGLOBAL:
	pMedium->hGlobal = DupGlobalMem(m_pStgMedium[idx].hGlobal);
	break;

	default:
	return DV_E_FORMATETC;
	}
	return S_OK;
	}

	HGLOBAL DataObjectWin::DupGlobalMem(HGLOBAL hMem) {
	DWORD len = GlobalSize(hMem);
	PVOID source = GlobalLock(hMem);
	PVOID dest = GlobalAlloc(GMEM_FIXED, len);

	memcpy(dest, source, len);
	GlobalUnlock(hMem);
	return dest;
	}

	int DataObjectWin::LookupFormatEtc(FORMATETC* pFormatEtc) {
	// check each of our formats in turn to see if one matches
	for (int i = 0; i < m_nNumFormats; i++) {
	if ((m_pFormatEtc[i].tymed & pFormatEtc->tymed) &&
	m_pFormatEtc[i].cfFormat == pFormatEtc->cfFormat &&
	m_pFormatEtc[i].dwAspect == pFormatEtc->dwAspect) {
	// return index of stored format
	return i;
	}
	}

	// error, format not found
	return -1;
	}

	DataObjectWin::DataObjectWin(FORMATETC* fmtetc, STGMEDIUM* stgmed, int count)
	: ref_count_(0) {
	m_nNumFormats = count;

	m_pFormatEtc = new FORMATETC[count];
	m_pStgMedium = new STGMEDIUM[count];

	for (int i = 0; i < count; i++) {
	m_pFormatEtc[i] = fmtetc[i];
	m_pStgMedium[i] = stgmed[i];
	}
	}

	} // namespace client

	#endif // defined(CEF_USE_ATL)