Prefix string16 with base:: in ui/.

ui/base/clipboard/clipboard_aurax11.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.h"
 
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <list>
 #include <set>
@@ skipping 550 matching lines @@
   return target_list.ContainsFormat(format);
 }
 
 void Clipboard::Clear(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   aurax11_details_->Clear(type);
 }
 
 void Clipboard::ReadAvailableTypes(ClipboardType type,
-                                   std::vector<string16>* types,
+                                   std::vector<base::string16>* types,
                                    bool* contains_filenames) const {
   DCHECK(CalledOnValidThread());
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
   TargetList target_list = aurax11_details_->WaitAndGetTargetsList(type);
 
   types->clear();
 
   if (target_list.ContainsText())
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (target_list.ContainsFormat(GetHtmlFormatType()))
     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
   if (target_list.ContainsFormat(GetRtfFormatType()))
     types->push_back(UTF8ToUTF16(kMimeTypeRTF));
   if (target_list.ContainsFormat(GetBitmapFormatType()))
     types->push_back(UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       type, aurax11_details_->GetAtomsForFormat(GetWebCustomDataFormatType())));
   if (data.IsValid())
     ReadCustomDataTypes(data.GetData(), data.GetSize(), types);
 }
 
-void Clipboard::ReadText(ClipboardType type, string16* result) const {
+void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
   DCHECK(CalledOnValidThread());
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       type, aurax11_details_->GetTextAtoms()));
   if (data.IsValid()) {
     std::string text = data.GetText();
     *result = UTF8ToUTF16(text);
   }
 }
 
 void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       type, aurax11_details_->GetTextAtoms()));
   if (data.IsValid())
     result->assign(data.GetText());
 }
 
 // TODO(estade): handle different charsets.
 // TODO(port): set *src_url.
 void Clipboard::ReadHTML(ClipboardType type,
-                         string16* markup,
+                         base::string16* markup,
                          std::string* src_url,
                          uint32* fragment_start,
                          uint32* fragment_end) const {
   DCHECK(CalledOnValidThread());
   markup->clear();
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
@@ skipping 25 matching lines @@
   if (data.IsValid()) {
     SkBitmap bitmap;
     if (gfx::PNGCodec::Decode(data.GetData(), data.GetSize(), &bitmap))
       return SkBitmap(bitmap);
   }
 
   return SkBitmap();
 }
 
 void Clipboard::ReadCustomData(ClipboardType clipboard_type,
-                               const string16& type,
-                               string16* result) const {
+                               const base::string16& type,
+                               base::string16* result) const {
   DCHECK(CalledOnValidThread());
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       clipboard_type,
       aurax11_details_->GetAtomsForFormat(GetWebCustomDataFormatType())));
   if (data.IsValid())
     ReadCustomDataForType(data.GetData(), data.GetSize(), type, result);
 }
 
-void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
   DCHECK(CalledOnValidThread());
   // TODO(erg): This was left NOTIMPLEMENTED() in the gtk port too.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   DCHECK(CalledOnValidThread());
 
   SelectionData data(aurax11_details_->RequestAndWaitForTypes(
       CLIPBOARD_TYPE_COPY_PASTE, aurax11_details_->GetAtomsForFormat(format)));
@@ skipping 39 matching lines @@
 
 void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
   WriteData(GetRtfFormatType(), rtf_data, data_len);
 }
 
 void Clipboard::WriteBookmark(const char* title_data,
                               size_t title_len,
                               const char* url_data,
                               size_t url_len) {
   // Write as a mozilla url (UTF16: URL, newline, title).
-  string16 url = UTF8ToUTF16(std::string(url_data, url_len) + "\n");
-  string16 title = UTF8ToUTF16(std::string(title_data, title_len));
+  base::string16 url = UTF8ToUTF16(std::string(url_data, url_len) + "\n");
+  base::string16 title = UTF8ToUTF16(std::string(title_data, title_len));
 
   std::vector<unsigned char> data;
   ui::AddString16ToVector(url, &data);
   ui::AddString16ToVector(title, &data);
   scoped_refptr<base::RefCountedMemory> mem(
       base::RefCountedBytes::TakeVector(&data));
 
   aurax11_details_->InsertMapping(kMimeTypeMozillaURL, mem);
 }
 
@@ skipping 97 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 }  // namespace ui