Add a unit test that filenames aren't unintentionally converted to URLs.

ui/base/dragdrop/os_exchange_data_provider_win.cc

 // Copyright (c) 2012 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 "ui/base/dragdrop/os_exchange_data_provider_win.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
@@ skipping 393 matching lines @@
   return ClipboardUtil::GetPlainText(source_object_, data);
 }
 
 bool OSExchangeDataProviderWin::GetURLAndTitle(
     OSExchangeData::FilenameToURLPolicy policy,
     GURL* url,
     base::string16* title) const {
   base::string16 url_str;
   bool success = ClipboardUtil::GetUrl(
       source_object_,
-      &url_str,
+      url,
       title,
       policy == OSExchangeData::CONVERT_FILENAMES ? true : false);
   if (success) {
-    GURL test_url(url_str);
-    if (test_url.is_valid()) {
-      *url = test_url;
-      return true;
-    }
+    DCHECK(url->is_valid());
+    return true;
   } else if (GetPlainTextURL(source_object_, url)) {
     if (url->is_valid())
       *title = net::GetSuggestedFilename(*url, "", "", "", "", std::string());
     else
       title->clear();
     return true;
   }
   return false;
 }
 
@@ skipping 19 matching lines @@
 
 bool OSExchangeDataProviderWin::GetPickledData(
     const OSExchangeData::CustomFormat& format,
     Pickle* data) const {
   DCHECK(data);
   bool success = false;
   STGMEDIUM medium;
   FORMATETC format_etc = format.ToFormatEtc();
   if (SUCCEEDED(source_object_->GetData(&format_etc, &medium))) {
     if (medium.tymed & TYMED_HGLOBAL) {
-      base::win::ScopedHGlobal<char> c_data(medium.hGlobal);
+      base::win::ScopedHGlobal<char*> c_data(medium.hGlobal);
       DCHECK_GT(c_data.Size(), 0u);
       *data = Pickle(c_data.get(), static_cast<int>(c_data.Size()));
       success = true;
     }
     ReleaseStgMedium(&medium);
   }
   return success;
 }
 
 bool OSExchangeDataProviderWin::GetFileContents(
@@ skipping 398 matching lines @@
   base::RefCountedThreadSafe<DownloadFileObserver>::Release();
   return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DataObjectImpl, private:
 
 static STGMEDIUM* GetStorageForBytes(const void* data, size_t bytes) {
   HANDLE handle = GlobalAlloc(GPTR, static_cast<int>(bytes));
   if (handle) {
-    base::win::ScopedHGlobal<uint8> scoped(handle);
+    base::win::ScopedHGlobal<uint8*> scoped(handle);
     memcpy(scoped.get(), data, bytes);
   }
 
   STGMEDIUM* storage = new STGMEDIUM;
   storage->hGlobal = handle;
   storage->tymed = TYMED_HGLOBAL;
   storage->pUnkForRelease = NULL;
   return storage;
 }
 
@@ skipping 36 matching lines @@
     validated->erase(max_length);
   *validated += extension;
 }
 
 static STGMEDIUM* GetStorageForFileName(const base::FilePath& path) {
   const size_t kDropSize = sizeof(DROPFILES);
   const size_t kTotalBytes =
       kDropSize + (path.value().length() + 2) * sizeof(wchar_t);
   HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kTotalBytes);
 
-  base::win::ScopedHGlobal<DROPFILES> locked_mem(hdata);
+  base::win::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 = (path.value().length() + 1) * sizeof(wchar_t);
   memcpy(data, path.value().c_str(), copy_size);
   data[path.value().length() + 1] = L'\0';  // Double NULL
 
   STGMEDIUM* storage = new STGMEDIUM;
@@ skipping 55 matching lines @@
   // NULL here to indicate that the parent folder is the desktop, and the second
   // is the PIDL of |path|.
   const size_t kPIDLCountSize = sizeof(UINT);
   const size_t kPIDLOffsetsSize = 2 * sizeof(UINT);
   const size_t kFirstPIDLOffset = kPIDLCountSize + kPIDLOffsetsSize;
   const size_t kFirstPIDLSize = 2;  // Empty PIDL - 2 NULL bytes.
   const size_t kSecondPIDLSize = PIDLSize(pidl);
   const size_t kCIDASize = kFirstPIDLOffset + kFirstPIDLSize + kSecondPIDLSize;
   HANDLE hdata = GlobalAlloc(GMEM_MOVEABLE, kCIDASize);
 
-  base::win::ScopedHGlobal<CIDA> locked_mem(hdata);
+  base::win::ScopedHGlobal<CIDA*> locked_mem(hdata);
   CIDA* cida = locked_mem.get();
   cida->cidl = 1;     // We have one PIDL (not including the 0th root PIDL).
   cida->aoffset[0] = kFirstPIDLOffset;
   cida->aoffset[1] = kFirstPIDLOffset + kFirstPIDLSize;
   LPITEMIDLIST idl = GetNthPIDL(cida, 0);
   idl->mkid.cb = 0;
   idl->mkid.abID[0] = 0;
   idl = GetNthPIDL(cida, 1);
   memcpy(idl, pidl, kSecondPIDLSize);
 
   STGMEDIUM* storage = new STGMEDIUM;
   storage->tymed = TYMED_HGLOBAL;
   storage->hGlobal = hdata;
   storage->pUnkForRelease = NULL;
   return storage;
 }
 
 static STGMEDIUM* GetStorageForFileDescriptor(
     const base::FilePath& path) {
   base::string16 file_name = path.value();
   DCHECK(!file_name.empty());
   HANDLE hdata = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));
-  base::win::ScopedHGlobal<FILEGROUPDESCRIPTOR> locked_mem(hdata);
+  base::win::ScopedHGlobal<FILEGROUPDESCRIPTOR*> locked_mem(hdata);
 
   FILEGROUPDESCRIPTOR* descriptor = locked_mem.get();
   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)));
 
   STGMEDIUM* storage = new STGMEDIUM;
   storage->tymed = TYMED_HGLOBAL;
   storage->hGlobal = hdata;
   storage->pUnkForRelease = NULL;
   return storage;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OSExchangeData, public:
 
 // static
 OSExchangeData::Provider* OSExchangeData::CreateProvider() {
   return new OSExchangeDataProviderWin();
 }
 
 }  // namespace ui