ui/base/dragdrop: Use base::string16 now that string16 was moved into base namespace.

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 15 matching lines @@
 // Creates a new STGMEDIUM object to hold the specified text. The caller
 // owns the resulting object. The "Bytes" version does not NULL terminate, the
 // string version does.
 static STGMEDIUM* GetStorageForBytes(const void* data, size_t bytes);
 template <typename T>
 static STGMEDIUM* GetStorageForString(const std::basic_string<T>& 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);
+                                         const base::string16& title,
+                                         base::string16* validated);
 // Creates a new STGMEDIUM object to hold a file.
 static STGMEDIUM* GetStorageForFileName(const base::FilePath& path);
 static STGMEDIUM* GetIDListStorageForFileName(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 base::FilePath& path);
 
 ///////////////////////////////////////////////////////////////////////////////
 // FormatEtcEnumerator
 
@@ skipping 156 matching lines @@
   // Carry over
   e->cursor_ = other->cursor_;
   return e;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OSExchangeDataProviderWin, public:
 
 // static
 bool OSExchangeDataProviderWin::HasPlainTextURL(IDataObject* source) {
-  string16 plain_text;
+  base::string16 plain_text;
   return (ClipboardUtil::GetPlainText(source, &plain_text) &&
           !plain_text.empty() && GURL(plain_text).is_valid());
 }
 
 // static
 bool OSExchangeDataProviderWin::GetPlainTextURL(IDataObject* source,
                                                 GURL* url) {
-  string16 plain_text;
+  base::string16 plain_text;
   if (ClipboardUtil::GetPlainText(source, &plain_text) &&
       !plain_text.empty()) {
     GURL gurl(plain_text);
     if (gurl.is_valid()) {
       *url = gurl;
       return true;
     }
   }
   return false;
 }
@@ skipping 25 matching lines @@
 }
 
 OSExchangeDataProviderWin::OSExchangeDataProviderWin()
     : data_(new DataObjectImpl()),
       source_object_(data_.get()) {
 }
 
 OSExchangeDataProviderWin::~OSExchangeDataProviderWin() {
 }
 
-void OSExchangeDataProviderWin::SetString(const string16& data) {
+void OSExchangeDataProviderWin::SetString(const base::string16& data) {
   STGMEDIUM* storage = GetStorageForString(data);
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetPlainTextWFormatType().ToFormatEtc(), storage));
 
   // Also add the UTF8-encoded version.
   storage = GetStorageForString(UTF16ToUTF8(data));
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetPlainTextFormatType().ToFormatEtc(), storage));
 }
 
 void OSExchangeDataProviderWin::SetURL(const GURL& url,
-                                       const string16& title) {
+                                       const base::string16& title) {
   // NOTE WELL:
   // Every time you change the order of the first two CLIPFORMATS that get
   // added here, you need to update the EnumerationViaCOM test case in
   // the _unittest.cc file to reflect the new arrangement otherwise that test
   // will fail! It assumes an insertion order.
 
   // Add text/x-moz-url for drags from Firefox
-  string16 x_moz_url_str = UTF8ToUTF16(url.spec());
+  base::string16 x_moz_url_str = UTF8ToUTF16(url.spec());
   x_moz_url_str += '\n';
   x_moz_url_str += title;
   STGMEDIUM* storage = GetStorageForString(x_moz_url_str);
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetMozUrlFormatType().ToFormatEtc(), storage));
 
   // Add a .URL shortcut file for dragging to Explorer.
-  string16 valid_file_name;
+  base::string16 valid_file_name;
   CreateValidFileNameFromTitle(url, title, &valid_file_name);
   std::string shortcut_url_file_contents;
   GetInternetShortcutFileContents(url, &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 = GetStorageForString(UTF8ToUTF16(url.spec()));
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetUrlWFormatType().ToFormatEtc(), storage));
   storage = GetStorageForString(url.spec());
@@ skipping 47 matching lines @@
   STGMEDIUM* storage = GetStorageForFileDescriptor(filename);
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetFileDescriptorFormatType().ToFormatEtc(), storage));
 
   // Add CFSTR_FILECONTENTS
   storage = GetStorageForBytes(file_contents.data(), file_contents.length());
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetFileContentZeroFormatType().ToFormatEtc(), storage));
 }
 
-void OSExchangeDataProviderWin::SetHtml(const string16& html,
+void OSExchangeDataProviderWin::SetHtml(const base::string16& 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 = UTF16ToUTF8(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());
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetHtmlFormatType().ToFormatEtc(), storage));
 
   STGMEDIUM* storage_plain = GetStorageForBytes(utf8_html.c_str(),
                                                 utf8_html.size());
   data_->contents_.push_back(new DataObjectImpl::StoredDataInfo(
       Clipboard::GetTextHtmlFormatType().ToFormatEtc(), storage_plain));
 }
 
-bool OSExchangeDataProviderWin::GetString(string16* data) const {
+bool OSExchangeDataProviderWin::GetString(base::string16* data) const {
   return ClipboardUtil::GetPlainText(source_object_, data);
 }
 
 bool OSExchangeDataProviderWin::GetURLAndTitle(GURL* url,
-                                               string16* title) const {
-  string16 url_str;
+                                               base::string16* title) const {
+  base::string16 url_str;
   bool success = ClipboardUtil::GetUrl(source_object_, &url_str, title, true);
   if (success) {
     GURL test_url(url_str);
     if (test_url.is_valid()) {
       *url = test_url;
       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;
 }
 
 bool OSExchangeDataProviderWin::GetFilename(base::FilePath* path) const {
-  std::vector<string16> filenames;
+  std::vector<base::string16> filenames;
   bool success = ClipboardUtil::GetFilenames(source_object_, &filenames);
   if (success)
     *path = base::FilePath(filenames[0]);
   return success;
 }
 
 bool OSExchangeDataProviderWin::GetFilenames(
     std::vector<OSExchangeData::FileInfo>* filenames) const {
-  std::vector<string16> filenames_local;
+  std::vector<base::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(base::FilePath(filenames_local[i]),
                                    base::FilePath()));
   }
   return success;
 }
 
@@ skipping 12 matching lines @@
       success = true;
     }
     ReleaseStgMedium(&medium);
   }
   return success;
 }
 
 bool OSExchangeDataProviderWin::GetFileContents(
     base::FilePath* filename,
     std::string* file_contents) const {
-  string16 filename_str;
+  base::string16 filename_str;
   if (!ClipboardUtil::GetFileContents(source_object_, &filename_str,
                                       file_contents)) {
     return false;
   }
   *filename = base::FilePath(filename_str);
   return true;
 }
 
-bool OSExchangeDataProviderWin::GetHtml(string16* html,
+bool OSExchangeDataProviderWin::GetHtml(base::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;
 }
 
 bool OSExchangeDataProviderWin::HasString() const {
   return ClipboardUtil::HasPlainText(source_object_);
@@ skipping 409 matching lines @@
                                             std::string* data) {
   DCHECK(data);
   static const std::string kInternetShortcutFileStart =
       "[InternetShortcut]\r\nURL=";
   static const std::string kInternetShortcutFileEnd =
       "\r\n";
   *data = kInternetShortcutFileStart + url.spec() + kInternetShortcutFileEnd;
 }
 
 static void CreateValidFileNameFromTitle(const GURL& url,
-                                         const string16& title,
-                                         string16* validated) {
+                                         const base::string16& title,
+                                         base::string16* validated) {
   if (title.empty()) {
     if (url.is_valid()) {
       *validated = net::GetSuggestedFilename(url, "", "", "", "",
                                              std::string());
     } else {
       // Nothing else can be done, just use a default.
       *validated =
           l10n_util::GetStringUTF16(IDS_APP_UNTITLED_SHORTCUT_FILE_NAME);
     }
   } else {
@@ skipping 102 matching lines @@
 
   STGMEDIUM* storage = new STGMEDIUM;
   storage->tymed = TYMED_HGLOBAL;
   storage->hGlobal = hdata;
   storage->pUnkForRelease = NULL;
   return storage;
 }
 
 static STGMEDIUM* GetStorageForFileDescriptor(
     const base::FilePath& path) {
-  string16 file_name = path.value();
+  base::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)));
 
   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