Replace FilePath with base::FilePath in some more top level directories.

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 <vector>
 
 #include "base/file_path.h"
@@ skipping 18 matching lines @@
 static STGMEDIUM* GetStorageForBytes(const char* data, size_t bytes);
 static STGMEDIUM* GetStorageForString16(const string16& 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 string16& title,
                                          string16* validated);
 // Creates a new STGMEDIUM object to hold a file.
-static STGMEDIUM* GetStorageForFileName(const FilePath& path);
+static STGMEDIUM* GetStorageForFileName(const base::FilePath& 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 FilePath& path);
+static STGMEDIUM* GetStorageForFileDescriptor(const base::FilePath& path);
 
 ///////////////////////////////////////////////////////////////////////////////
 // FormatEtcEnumerator
 
 //
 // This object implements an enumeration interface. The existence of an
 // implementation of this interface is exposed to clients through
 // OSExchangeData's EnumFormatEtc method. Our implementation is nobody's
 // business but our own, so it lives in this file.
 //
@@ skipping 237 matching lines @@
   x_moz_url_str += title;
   STGMEDIUM* storage = GetStorageForString16(x_moz_url_str);
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       ClipboardUtil::GetMozUrlFormat()->cfFormat, storage));
 
   // Add a .URL shortcut file for dragging to Explorer.
   string16 valid_file_name;
   CreateValidFileNameFromTitle(url, title, &valid_file_name);
   std::string shortcut_url_file_contents;
   GetInternetShortcutFileContents(url, &shortcut_url_file_contents);
-  SetFileContents(FilePath(valid_file_name), shortcut_url_file_contents);
+  SetFileContents(base::FilePath(valid_file_name), shortcut_url_file_contents);
 
   // Add a UniformResourceLocator link for apps like IE and Word.
   storage = GetStorageForString16(UTF8ToUTF16(url.spec()));
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       ClipboardUtil::GetUrlWFormat()->cfFormat, storage));
   storage = GetStorageForString(url.spec());
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       ClipboardUtil::GetUrlFormat()->cfFormat, storage));
 
   // TODO(beng): add CF_HTML.
   // http://code.google.com/p/chromium/issues/detail?id=6767
 
   // Also add text representations (these should be last since they're the
   // least preferable).
   storage = GetStorageForString16(UTF8ToUTF16(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 FilePath& path) {
+void OSExchangeDataProviderWin::SetFilename(const base::FilePath& path) {
   STGMEDIUM* storage = GetStorageForFileName(path);
   DataObjectImpl::StoredDataInfo* info =
       new DataObjectImpl::StoredDataInfo(CF_HDROP, storage);
   data_->contents_.push_back(info);
 }
 
 void OSExchangeDataProviderWin::SetFilenames(
     const std::vector<OSExchangeData::FileInfo>& filenames) {
   for (size_t i = 0; i < filenames.size(); ++i) {
     STGMEDIUM* storage = GetStorageForFileName(filenames[i].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 = GetStorageForBytes(static_cast<const char*>(data.data()),
                                           data.size());
   data_->contents_.push_back(
       new DataObjectImpl::StoredDataInfo(format, storage));
 }
 
 void OSExchangeDataProviderWin::SetFileContents(
-    const FilePath& filename,
+    const base::FilePath& 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(), storage));
@@ skipping 33 matching lines @@
   } else if (GetPlainTextURL(source_object_, url)) {
     if (url->is_valid())
       *title = net::GetSuggestedFilename(*url, "", "", "", "", std::string());
     else
       title->clear();
     return true;
   }
   return false;
 }
 
-bool OSExchangeDataProviderWin::GetFilename(FilePath* path) const {
+bool OSExchangeDataProviderWin::GetFilename(base::FilePath* path) const {
   std::vector<string16> filenames;
   bool success = ClipboardUtil::GetFilenames(source_object_, &filenames);
   if (success)
-    *path = FilePath(filenames[0]);
+    *path = base::FilePath(filenames[0]);
   return success;
 }
 
 bool OSExchangeDataProviderWin::GetFilenames(
     std::vector<OSExchangeData::FileInfo>* filenames) const {
   std::vector<string16> filenames_local;
   bool success = ClipboardUtil::GetFilenames(source_object_, &filenames_local);
   if (success) {
     for (size_t i = 0; i < filenames_local.size(); ++i)
       filenames->push_back(
-          OSExchangeData::FileInfo(FilePath(filenames_local[i]), FilePath()));
+          OSExchangeData::FileInfo(base::FilePath(filenames_local[i]),
+                                   base::FilePath()));
   }
   return success;
 }
 
 bool OSExchangeDataProviderWin::GetPickledData(CLIPFORMAT format,
                                                Pickle* data) const {
   DCHECK(data);
   FORMATETC format_etc =
       { format, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
   bool success = false;
   STGMEDIUM medium;
   if (SUCCEEDED(source_object_->GetData(&format_etc, &medium))) {
     if (medium.tymed & TYMED_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(
-    FilePath* filename,
+    base::FilePath* filename,
     std::string* file_contents) const {
   string16 filename_str;
   if (!ClipboardUtil::GetFileContents(source_object_, &filename_str,
                                       file_contents)) {
     return false;
   }
-  *filename = FilePath(filename_str);
+  *filename = base::FilePath(filename_str);
   return true;
 }
 
 bool OSExchangeDataProviderWin::GetHtml(string16* html,
                                         GURL* base_url) const {
   std::string url;
   bool success = ClipboardUtil::GetHtml(source_object_, html, &url);
   if (success)
     *base_url = GURL(url);
   return success;
@@ skipping 168 matching lines @@
         format.dwAspect == (*i)->format_etc.dwAspect &&
         format.lindex == (*i)->format_etc.lindex &&
         format.tymed == (*i)->format_etc.tymed) {
       delete *i;
       contents_.erase(i);
       return;
     }
   }
 }
 
-void DataObjectImpl::OnDownloadCompleted(const FilePath& file_path) {
+void DataObjectImpl::OnDownloadCompleted(const base::FilePath& file_path) {
   CLIPFORMAT hdrop_format = ClipboardUtil::GetCFHDropFormat()->cfFormat;
   DataObjectImpl::StoredData::iterator iter = contents_.begin();
   for (; iter != contents_.end(); ++iter) {
     if ((*iter)->format_etc.cfFormat == hdrop_format) {
       // Release the old storage.
       if ((*iter)->owns_medium) {
         ReleaseStgMedium((*iter)->medium);
         delete (*iter)->medium;
       }
 
@@ skipping 277 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 FilePath& path) {
+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);
   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;
   storage->tymed = TYMED_HGLOBAL;
   storage->hGlobal = hdata;
   storage->pUnkForRelease = NULL;
   return storage;
 }
 
 static STGMEDIUM* GetStorageForFileDescriptor(
-    const FilePath& path) {
+    const base::FilePath& path) {
   string16 file_name = path.value();
   DCHECK(!file_name.empty());
   HANDLE hdata = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));
   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)));
@@ skipping 13 matching lines @@
   return new OSExchangeDataProviderWin();
 }
 
 // static
 OSExchangeData::CustomFormat OSExchangeData::RegisterCustomFormat(
     const std::string& type) {
   return RegisterClipboardFormat(ASCIIToUTF16(type).c_str());
 }
 
 }  // namespace ui