Prefix string16 with base:: in ui/.

ui/base/clipboard/clipboard_util_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/clipboard/clipboard_util_win.h"
 
 #include <shellapi.h>
 #include <shlwapi.h>
 #include <wininet.h>  // For INTERNET_MAX_URL_LENGTH.
 
@@ skipping 16 matching lines @@
   return SUCCEEDED(data_object->QueryGetData(&format_etc));
 }
 
 bool GetData(IDataObject* data_object,
              const Clipboard::FormatType& format,
              STGMEDIUM* medium) {
   FORMATETC format_etc = format.ToFormatEtc();
   return SUCCEEDED(data_object->GetData(&format_etc, medium));
 }
 
-bool GetUrlFromHDrop(IDataObject* data_object, string16* url, string16* title) {
+bool GetUrlFromHDrop(IDataObject* data_object,
+                     base::string16* url,
+                     base::string16* title) {
   DCHECK(data_object && url && title);
 
   STGMEDIUM medium;
   if (!GetData(data_object, Clipboard::GetCFHDropFormatType(), &medium))
     return false;
 
   HDROP hdrop = static_cast<HDROP>(GlobalLock(medium.hGlobal));
 
   if (!hdrop)
     return false;
@@ skipping 12 matching lines @@
     }
   }
 
   DragFinish(hdrop);
   GlobalUnlock(medium.hGlobal);
   // We don't need to call ReleaseStgMedium here because as far as I can tell,
   // DragFinish frees the hGlobal for us.
   return success;
 }
 
-void SplitUrlAndTitle(const string16& str,
-                      string16* url,
-                      string16* title) {
+void SplitUrlAndTitle(const base::string16& str,
+                      base::string16* url,
+                      base::string16* title) {
   DCHECK(url && title);
   size_t newline_pos = str.find('\n');
-  if (newline_pos != string16::npos) {
+  if (newline_pos != base::string16::npos) {
     url->assign(str, 0, newline_pos);
-    title->assign(str, newline_pos + 1, string16::npos);
+    title->assign(str, newline_pos + 1, base::string16::npos);
   } else {
     url->assign(str);
     title->assign(str);
   }
 }
 
-bool GetFileUrl(IDataObject* data_object, string16* url,
-                string16* title) {
+bool GetFileUrl(IDataObject* data_object, base::string16* url,
+                base::string16* title) {
   STGMEDIUM store;
   if (GetData(data_object, Clipboard::GetFilenameWFormatType(), &store)) {
     bool success = false;
     {
       // filename using unicode
       base::win::ScopedHGlobal<wchar_t> data(store.hGlobal);
       if (data.get() && data.get()[0] &&
           (PathFileExists(data.get()) || PathIsUNC(data.get()))) {
         wchar_t file_url[INTERNET_MAX_URL_LENGTH];
         DWORD file_url_len = arraysize(file_url);
@@ skipping 61 matching lines @@
          HasData(data_object, Clipboard::GetTextHtmlFormatType());
 }
 
 bool ClipboardUtil::HasPlainText(IDataObject* data_object) {
   DCHECK(data_object);
   return HasData(data_object, Clipboard::GetPlainTextWFormatType()) ||
          HasData(data_object, Clipboard::GetPlainTextFormatType());
 }
 
 bool ClipboardUtil::GetUrl(IDataObject* data_object,
-    string16* url, string16* title, bool convert_filenames) {
+    base::string16* url, base::string16* title, bool convert_filenames) {
   DCHECK(data_object && url && title);
   if (!HasUrl(data_object))
     return false;
 
   // Try to extract a URL from |data_object| in a variety of formats.
   STGMEDIUM store;
   if (GetUrlFromHDrop(data_object, url, title))
     return true;
 
   if (GetData(data_object, Clipboard::GetMozUrlFormatType(), &store) ||
@@ skipping 18 matching lines @@
   }
 
   if (convert_filenames) {
     return GetFileUrl(data_object, url, title);
   } else {
     return false;
   }
 }
 
 bool ClipboardUtil::GetFilenames(IDataObject* data_object,
-                                 std::vector<string16>* filenames) {
+                                 std::vector<base::string16>* filenames) {
   DCHECK(data_object && filenames);
   if (!HasFilenames(data_object))
     return false;
 
   STGMEDIUM medium;
   if (!GetData(data_object, Clipboard::GetCFHDropFormatType(), &medium))
     return false;
 
   HDROP hdrop = static_cast<HDROP>(GlobalLock(medium.hGlobal));
   if (!hdrop)
     return false;
 
   const int kMaxFilenameLen = 4096;
   const unsigned num_files = DragQueryFileW(hdrop, 0xffffffff, 0, 0);
   for (unsigned int i = 0; i < num_files; ++i) {
     wchar_t filename[kMaxFilenameLen];
     if (!DragQueryFileW(hdrop, i, filename, kMaxFilenameLen))
       continue;
     filenames->push_back(filename);
   }
 
   DragFinish(hdrop);
   GlobalUnlock(medium.hGlobal);
   // We don't need to call ReleaseStgMedium here because as far as I can tell,
   // DragFinish frees the hGlobal for us.
   return true;
 }
 
 bool ClipboardUtil::GetPlainText(IDataObject* data_object,
-                                 string16* plain_text) {
+                                 base::string16* plain_text) {
   DCHECK(data_object && plain_text);
   if (!HasPlainText(data_object))
     return false;
 
   STGMEDIUM store;
   if (GetData(data_object, Clipboard::GetPlainTextWFormatType(), &store)) {
     {
       // Unicode text
       base::win::ScopedHGlobal<wchar_t> data(store.hGlobal);
       plain_text->assign(data.get());
     }
     ReleaseStgMedium(&store);
     return true;
   }
 
   if (GetData(data_object, Clipboard::GetPlainTextFormatType(), &store)) {
     {
       // ascii text
       base::win::ScopedHGlobal<char> data(store.hGlobal);
       plain_text->assign(UTF8ToWide(data.get()));
     }
     ReleaseStgMedium(&store);
     return true;
   }
 
   // If a file is dropped on the window, it does not provide either of the
   // plain text formats, so here we try to forcibly get a url.
-  string16 title;
+  base::string16 title;
   return GetUrl(data_object, plain_text, &title, false);
 }
 
 bool ClipboardUtil::GetHtml(IDataObject* data_object,
-                            string16* html, std::string* base_url) {
+                            base::string16* html, std::string* base_url) {
   DCHECK(data_object && html && base_url);
 
   STGMEDIUM store;
   if (HasData(data_object, Clipboard::GetHtmlFormatType()) &&
       GetData(data_object, Clipboard::GetHtmlFormatType(), &store)) {
     {
       // MS CF html
       base::win::ScopedHGlobal<char> data(store.hGlobal);
 
       std::string html_utf8;
@@ skipping 13 matching lines @@
   {
     // text/html
     base::win::ScopedHGlobal<wchar_t> data(store.hGlobal);
     html->assign(data.get());
   }
   ReleaseStgMedium(&store);
   return true;
 }
 
 bool ClipboardUtil::GetFileContents(IDataObject* data_object,
-    string16* filename, std::string* file_contents) {
+    base::string16* filename, std::string* file_contents) {
   DCHECK(data_object && filename && file_contents);
   if (!HasData(data_object, Clipboard::GetFileContentZeroFormatType()) &&
       !HasData(data_object, Clipboard::GetFileDescriptorFormatType()))
     return false;
 
   STGMEDIUM content;
   // The call to GetData can be very slow depending on what is in
   // |data_object|.
   if (GetData(
           data_object, Clipboard::GetFileContentZeroFormatType(), &content)) {
@@ skipping 13 matching lines @@
       // We expect there to be at least one file in here.
       DCHECK_GE(fgd->cItems, 1u);
       filename->assign(fgd->fgd[0].cFileName);
     }
     ReleaseStgMedium(&description);
   }
   return true;
 }
 
 bool ClipboardUtil::GetWebCustomData(
-    IDataObject* data_object, std::map<string16, string16>* custom_data) {
+    IDataObject* data_object,
+    std::map<base::string16, base::string16>* custom_data) {
   DCHECK(data_object && custom_data);
 
   if (!HasData(data_object, Clipboard::GetWebCustomDataFormatType()))
     return false;
 
   STGMEDIUM store;
   if (GetData(data_object, Clipboard::GetWebCustomDataFormatType(), &store)) {
     {
       base::win::ScopedHGlobal<char> data(store.hGlobal);
       ReadCustomDataIntoMap(data.get(), data.Size(), custom_data);
@@ skipping 152 matching lines @@
           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);
   }
 }
 
 }  // namespace ui