Prefix string16 with base:: in ui/.

ui/base/clipboard/clipboard_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.
 
 // Many of these functions are based on those found in
 // webkit/port/platform/PasteboardWin.cpp
 
 #include "ui/base/clipboard/clipboard.h"
 
 #include <shlobj.h>
@@ skipping 209 matching lines @@
 
   ::EmptyClipboard();
 
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
-  string16 text;
+  base::string16 text;
   UTF8ToUTF16(text_data, text_len, &text);
   HGLOBAL glob = CreateGlobalData(text);
 
   WriteToClipboard(CF_UNICODETEXT, glob);
 }
 
 void Clipboard::WriteHTML(const char* markup_data,
                           size_t markup_len,
                           const char* url_data,
                           size_t url_len) {
@@ skipping 14 matching lines @@
 }
 
 void Clipboard::WriteBookmark(const char* title_data,
                               size_t title_len,
                               const char* url_data,
                               size_t url_len) {
   std::string bookmark(title_data, title_len);
   bookmark.append(1, L'\n');
   bookmark.append(url_data, url_len);
 
-  string16 wide_bookmark = UTF8ToWide(bookmark);
+  base::string16 wide_bookmark = UTF8ToWide(bookmark);
   HGLOBAL glob = CreateGlobalData(wide_bookmark);
 
   WriteToClipboard(GetUrlWFormatType().ToUINT(), glob);
 }
 
 void Clipboard::WriteWebSmartPaste() {
   DCHECK(clipboard_owner_->hwnd() != NULL);
   ::SetClipboardData(GetWebKitSmartPasteFormatType().ToUINT(), NULL);
 }
 
@@ skipping 112 matching lines @@
 void Clipboard::Clear(ClipboardType type) {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   ::EmptyClipboard();
 }
 
 void Clipboard::ReadAvailableTypes(ClipboardType type,
-                                   std::vector<string16>* types,
+                                   std::vector<base::string16>* types,
                                    bool* contains_filenames) const {
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
   types->clear();
   if (::IsClipboardFormatAvailable(GetPlainTextFormatType().ToUINT()))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (::IsClipboardFormatAvailable(GetHtmlFormatType().ToUINT()))
@@ skipping 10 matching lines @@
     return;
 
   HANDLE hdata = ::GetClipboardData(GetWebCustomDataFormatType().ToUINT());
   if (!hdata)
     return;
 
   ReadCustomDataTypes(::GlobalLock(hdata), ::GlobalSize(hdata), types);
   ::GlobalUnlock(hdata);
 }
 
-void Clipboard::ReadText(ClipboardType type, string16* result) const {
+void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   if (!result) {
     NOTREACHED();
     return;
   }
 
   result->clear();
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
@@ skipping 24 matching lines @@
 
   HANDLE data = ::GetClipboardData(CF_TEXT);
   if (!data)
     return;
 
   result->assign(static_cast<const char*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 }
 
 void Clipboard::ReadHTML(ClipboardType type,
-                         string16* markup,
+                         base::string16* markup,
                          std::string* src_url,
                          uint32* fragment_start,
                          uint32* fragment_end) const {
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
 
   markup->clear();
   // TODO(dcheng): Remove these checks, I don't think they should be optional.
   DCHECK(src_url);
   if (src_url)
     src_url->clear();
@@ skipping 107 matching lines @@
         BitmapHasInvalidPremultipliedColors(device_bitmap);
     if (has_invalid_alpha_channel) {
       MakeBitmapOpaque(device_bitmap);
     }
   }
 
   return canvas.ExtractImageRep().sk_bitmap();
 }
 
 void Clipboard::ReadCustomData(ClipboardType clipboard_type,
-                               const string16& type,
-                               string16* result) const {
+                               const base::string16& type,
+                               base::string16* result) const {
   DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE);
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   HANDLE hdata = ::GetClipboardData(GetWebCustomDataFormatType().ToUINT());
   if (!hdata)
     return;
 
   ReadCustomDataForType(::GlobalLock(hdata), ::GlobalSize(hdata), type, result);
   ::GlobalUnlock(hdata);
 }
 
-void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
   if (title)
     title->clear();
 
   if (url)
     url->clear();
 
   // Acquire the clipboard.
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   HANDLE data = ::GetClipboardData(GetUrlWFormatType().ToUINT());
   if (!data)
     return;
 
-  string16 bookmark(static_cast<const char16*>(::GlobalLock(data)));
+  base::string16 bookmark(static_cast<const char16*>(::GlobalLock(data)));
   ::GlobalUnlock(data);
 
   ParseBookmarkClipboardFormat(bookmark, title, url);
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   if (!result) {
     NOTREACHED();
     return;
   }
 
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
   HANDLE data = ::GetClipboardData(format.ToUINT());
   if (!data)
     return;
 
   result->assign(static_cast<const char*>(::GlobalLock(data)),
                  ::GlobalSize(data));
   ::GlobalUnlock(data);
 }
 
 // static
-void Clipboard::ParseBookmarkClipboardFormat(const string16& bookmark,
-                                             string16* title,
+void Clipboard::ParseBookmarkClipboardFormat(const base::string16& bookmark,
+                                             base::string16* title,
                                              std::string* url) {
-  const string16 kDelim = ASCIIToUTF16("\r\n");
+  const base::string16 kDelim = ASCIIToUTF16("\r\n");
 
   const size_t title_end = bookmark.find_first_of(kDelim);
   if (title)
     title->assign(bookmark.substr(0, title_end));
 
   if (url) {
     const size_t url_start = bookmark.find_first_not_of(kDelim, title_end);
-    if (url_start != string16::npos)
-      *url = UTF16ToUTF8(bookmark.substr(url_start, string16::npos));
+    if (url_start != base::string16::npos)
+      *url = UTF16ToUTF8(bookmark.substr(url_start, base::string16::npos));
   }
 }
 
 // static
 Clipboard::FormatType Clipboard::GetFormatType(
     const std::string& format_string) {
   return FormatType(
       ::RegisterClipboardFormat(ASCIIToWide(format_string).c_str()));
 }
 
@@ skipping 141 matching lines @@
   if (!clipboard_owner_)
     return NULL;
 
   if (clipboard_owner_->hwnd() == NULL)
     clipboard_owner_->Create(base::Bind(&ClipboardOwnerWndProc));
 
   return clipboard_owner_->hwnd();
 }
 
 }  // namespace ui