Move more uses of string16 to specify base::

ui/base/clipboard/clipboard_gtk.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 <gtk/gtk.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <map>
@@ skipping 299 matching lines @@
 
   // We store the GdkPixbuf*, and the size_t half of the pair is meaningless.
   // Note that this contrasts with the vast majority of entries in our target
   // map, which directly store the data and its length.
   InsertMapping(kMimeTypeBitmap, reinterpret_cast<char*>(pixbuf), 0);
 }
 
 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));
   if (title.length() >= std::numeric_limits<size_t>::max() / 4 ||
       url.length() >= std::numeric_limits<size_t>::max() / 4)
     return;
   size_t data_len = 2 * (title.length() + url.length());
 
   char* data = new char[data_len];
   memcpy(data, url.data(), 2 * url.length());
   memcpy(data + 2 * url.length(), title.data(), 2 * title.length());
   InsertMapping(kMimeTypeMozillaURL, data, data_len);
 }
@@ skipping 68 matching lines @@
 
 void Clipboard::Clear(ClipboardType type) {
   DCHECK(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(type);
   if (clipboard == NULL)
     return;
   gtk_clipboard_clear(clipboard);
 }
 
 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();
   if (IsFormatAvailable(GetPlainTextFormatType(), type))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
@@ skipping 13 matching lines @@
       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataTypes(gtk_selection_data_get_data(data),
                       gtk_selection_data_get_length(data),
                       types);
   gtk_selection_data_free(data);
 }
 
 
-void Clipboard::ReadText(ClipboardType type, string16* result) const {
+void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
   DCHECK(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(type);
   if (clipboard == NULL)
     return;
 
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard);
 
   if (text == NULL)
     return;
@@ skipping 16 matching lines @@
   if (text == NULL)
     return;
 
   result->assign(text);
   g_free(text);
 }
 
 // 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 48 matching lines @@
   {
     skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
     cairo_t* context = scoped_platform_paint.GetPlatformSurface();
     gdk_cairo_set_source_pixbuf(context, pixbuf.get(), 0.0, 0.0);
     cairo_paint(context);
   }
   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(CalledOnValidThread());
   GtkClipboard* clipboard = LookupBackingClipboard(clipboard_type);
   if (!clipboard)
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataForType(gtk_selection_data_get_data(data),
                         gtk_selection_data_get_length(data),
                         type, result);
   gtk_selection_data_free(data);
 }
 
-void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
   // TODO(estade): implement this.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   DCHECK(CalledOnValidThread());
   result->clear();
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard_, format.ToGdkAtom());
   if (!data)
@@ skipping 89 matching lines @@
       return clipboard_;
     case CLIPBOARD_TYPE_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace ui