Prefix string16 with base:: in ui/.

ui/base/clipboard/clipboard_aura.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 <list>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
@@ skipping 168 matching lines @@
   bool IsFormatAvailable(AuraClipboardFormat format) const {
     switch (format) {
       case TEXT:
         return HasFormat(TEXT) || HasFormat(BOOKMARK);
       default:
         return HasFormat(format);
     }
   }
 
   // Reads text from the data at the top of clipboard stack.
-  void ReadText(string16* result) const {
+  void ReadText(base::string16* result) const {
     std::string utf8_result;
     ReadAsciiText(&utf8_result);
     *result = UTF8ToUTF16(utf8_result);
   }
 
   // Reads ascii text from the data at the top of clipboard stack.
   void ReadAsciiText(std::string* result) const {
     result->clear();
     const ClipboardData* data = GetData();
     if (!data)
       return;
     if (HasFormat(TEXT))
       *result = data->text();
     else if (HasFormat(HTML))
       *result = data->markup_data();
     else if (HasFormat(BOOKMARK))
       *result = data->bookmark_url();
   }
 
   // Reads HTML from the data at the top of clipboard stack.
-  void ReadHTML(string16* markup,
+  void ReadHTML(base::string16* markup,
                 std::string* src_url,
                 uint32* fragment_start,
                 uint32* fragment_end) const {
     markup->clear();
     if (src_url)
       src_url->clear();
     *fragment_start = 0;
     *fragment_end = 0;
 
     if (!HasFormat(HTML))
@@ skipping 24 matching lines @@
     if (!HasFormat(BITMAP))
       return img;
 
     // A shallow copy should be fine here, but just to be safe...
     const SkBitmap& clipboard_bitmap = GetData()->bitmap();
     clipboard_bitmap.copyTo(&img, clipboard_bitmap.getConfig());
     return img;
   }
 
   // Reads data of type |type| from the data at the top of clipboard stack.
-  void ReadCustomData(const string16& type, string16* result) const {
+  void ReadCustomData(const base::string16& type,
+                      base::string16* result) const {
     result->clear();
     const ClipboardData* data = GetData();
     if (!HasFormat(CUSTOM))
       return;
 
     ui::ReadCustomDataForType(data->custom_data_data().c_str(),
         data->custom_data_data().size(),
         type, result);
   }
 
   // Reads bookmark from the data at the top of clipboard stack.
-  void ReadBookmark(string16* title, std::string* url) const {
+  void ReadBookmark(base::string16* title, std::string* url) const {
     title->clear();
     url->clear();
     if (!HasFormat(BOOKMARK))
       return;
 
     const ClipboardData* data = GetData();
     *title = UTF8ToUTF16(data->bookmark_title());
     *url = data->bookmark_url();
   }
 
@@ skipping 196 matching lines @@
 }
 
 void Clipboard::Clear(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsSupportedClipboardType(type));
   AuraClipboard* clipboard = GetClipboard();
   clipboard->Clear();
 }
 
 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;
   }
 
   types->clear();
   *contains_filenames = false;
   if (IsFormatAvailable(GetPlainTextFormatType(), type))
     types->push_back(UTF8ToUTF16(GetPlainTextFormatType().ToString()));
   if (IsFormatAvailable(GetHtmlFormatType(), type))
     types->push_back(UTF8ToUTF16(GetHtmlFormatType().ToString()));
   if (IsFormatAvailable(GetRtfFormatType(), type))
     types->push_back(UTF8ToUTF16(GetRtfFormatType().ToString()));
   if (IsFormatAvailable(GetBitmapFormatType(), type))
     types->push_back(UTF8ToUTF16(kMimeTypePNG));
 
   AuraClipboard* clipboard = GetClipboard();
   if (clipboard->IsFormatAvailable(CUSTOM) && clipboard->GetData()) {
     ui::ReadCustomDataTypes(clipboard->GetData()->custom_data_data().c_str(),
         clipboard->GetData()->custom_data_data().size(), types);
   }
 }
 
-void Clipboard::ReadText(ClipboardType type, string16* result) const {
+void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadText(result);
 }
 
 void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadAsciiText(result);
 }
 
 void Clipboard::ReadHTML(ClipboardType type,
-                         string16* markup,
+                         base::string16* markup,
                          std::string* src_url,
                          uint32* fragment_start,
                          uint32* fragment_end) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end);
 }
 
 void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadRTF(result);
 }
 
 SkBitmap Clipboard::ReadImage(ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   return GetClipboard()->ReadImage();
 }
 
 void Clipboard::ReadCustomData(ClipboardType clipboard_type,
-                               const string16& type,
-                               string16* result) const {
+                               const base::string16& type,
+                               base::string16* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadCustomData(type, result);
 }
 
-void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadBookmark(title, url);
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   DCHECK(CalledOnValidThread());
   GetClipboard()->ReadData(format.ToString(), result);
 }
 
 uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
@@ skipping 106 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 }  // namespace ui