ui/base/dragdrop: Use base::string16 now that string16 was moved into base namespace.

ui/base/dragdrop/os_exchange_data_provider_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/dragdrop/os_exchange_data_provider_aurax11.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_pump_aurax11.h"
 #include "base/strings/string_util.h"
@@ skipping 84 matching lines @@
     std::vector<Atom>* targets) const {
   selection_owner_.RetrieveTargets(targets);
 }
 
 SelectionFormatMap OSExchangeDataProviderAuraX11::GetFormatMap() const {
   // We return the |selection_owner_|'s format map instead of our own in case
   // ours has been modified since TakeOwnershipOfSelection() was called.
   return selection_owner_.selection_format_map();
 }
 
-void OSExchangeDataProviderAuraX11::SetString(const string16& text_data) {
+void OSExchangeDataProviderAuraX11::SetString(const base::string16& text_data) {
   std::string utf8 = UTF16ToUTF8(text_data);
   scoped_refptr<base::RefCountedMemory> mem(
       base::RefCountedString::TakeString(&utf8));
 
   format_map_.Insert(atom_cache_.GetAtom(Clipboard::kMimeTypeText), mem);
   format_map_.Insert(atom_cache_.GetAtom(kText), mem);
   format_map_.Insert(atom_cache_.GetAtom(kString), mem);
   format_map_.Insert(atom_cache_.GetAtom(kUtf8String), mem);
 }
 
 void OSExchangeDataProviderAuraX11::SetURL(const GURL& url,
-                                           const string16& title) {
+                                           const base::string16& title) {
   NOTIMPLEMENTED();
 }
 
 void OSExchangeDataProviderAuraX11::SetFilename(const base::FilePath& path) {
   NOTIMPLEMENTED();
 }
 
 void OSExchangeDataProviderAuraX11::SetFilenames(
     const std::vector<OSExchangeData::FileInfo>& filenames) {
   NOTIMPLEMENTED();
 }
 
 void OSExchangeDataProviderAuraX11::SetPickledData(
     const OSExchangeData::CustomFormat& format,
     const Pickle& data) {
   NOTIMPLEMENTED();
 }
 
-bool OSExchangeDataProviderAuraX11::GetString(string16* result) const {
+bool OSExchangeDataProviderAuraX11::GetString(base::string16* result) const {
   std::vector< ::Atom> text_atoms = ui::GetTextAtomsFrom(&atom_cache_);
   std::vector< ::Atom> requested_types;
   ui::GetAtomIntersection(text_atoms, GetTargets(), &requested_types);
 
   ui::SelectionData data(format_map_.GetFirstOf(requested_types));
   if (data.IsValid()) {
     std::string text = data.GetText();
     *result = UTF8ToUTF16(text);
     return true;
   }
 
   return false;
 }
 
-bool OSExchangeDataProviderAuraX11::GetURLAndTitle(GURL* url,
-                                                   string16* title) const {
+bool OSExchangeDataProviderAuraX11::GetURLAndTitle(
+    GURL* url,
+    base::string16* title) const {
   std::vector< ::Atom> url_atoms = ui::GetURLAtomsFrom(&atom_cache_);
   std::vector< ::Atom> requested_types;
   ui::GetAtomIntersection(url_atoms, GetTargets(), &requested_types);
 
   ui::SelectionData data(format_map_.GetFirstOf(requested_types));
   if (data.IsValid()) {
     // TODO(erg): Technically, both of these forms can accept multiple URLs,
     // but that doesn't match the assumptions of the rest of the system which
     // expect single types.
 
     if (data.GetType() == atom_cache_.GetAtom(kMimeTypeMozillaURL)) {
       // Mozilla URLs are (UTF16: URL, newline, title).
-      string16 unparsed;
+      base::string16 unparsed;
       data.AssignTo(&unparsed);
 
-      std::vector<string16> tokens;
+      std::vector<base::string16> tokens;
       size_t num_tokens = Tokenize(unparsed, ASCIIToUTF16("\n"), &tokens);
       if (num_tokens >= 2) {
         *url = GURL(tokens[0]);
         *title = tokens[1];
         return true;
       } else {
         NOTREACHED() << "Data that claimed to be a Mozilla URL has "
                      << num_tokens << " tokens instead of 2.";
       }
     } else if (data.GetType() == atom_cache_.GetAtom(
                    Clipboard::kMimeTypeURIList)) {
       // uri-lists are newline separated file lists in URL encoding.
       std::string unparsed;
       data.AssignTo(&unparsed);
 
       std::vector<std::string> tokens;
       size_t num_tokens = Tokenize(unparsed, "\n", &tokens);
       if (!num_tokens) {
         NOTREACHED() << "Empty URI list";
         return false;
       }
 
       *url = GURL(tokens[0]);
-      *title = string16();
+      *title = base::string16();
 
       return true;
     }
   }
 
   return false;
 }
 
 bool OSExchangeDataProviderAuraX11::GetFilename(base::FilePath* path) const {
   // On X11, files are passed by URL and aren't separate.
@@ skipping 35 matching lines @@
 bool OSExchangeDataProviderAuraX11::HasCustomFormat(
     const OSExchangeData::CustomFormat& format) const {
   std::vector< ::Atom> url_atoms;
   url_atoms.push_back(atom_cache_.GetAtom(format.ToString().c_str()));
   std::vector< ::Atom> requested_types;
   ui::GetAtomIntersection(url_atoms, GetTargets(), &requested_types);
 
   return !requested_types.empty();
 }
 
-void OSExchangeDataProviderAuraX11::SetHtml(const string16& html,
+void OSExchangeDataProviderAuraX11::SetHtml(const base::string16& html,
                                             const GURL& base_url) {
   NOTIMPLEMENTED();
 }
 
-bool OSExchangeDataProviderAuraX11::GetHtml(string16* html,
+bool OSExchangeDataProviderAuraX11::GetHtml(base::string16* html,
                                             GURL* base_url) const {
   std::vector< ::Atom> url_atoms;
   url_atoms.push_back(atom_cache_.GetAtom(Clipboard::kMimeTypeHTML));
   std::vector< ::Atom> requested_types;
   ui::GetAtomIntersection(url_atoms, GetTargets(), &requested_types);
 
   ui::SelectionData data(format_map_.GetFirstOf(requested_types));
   if (data.IsValid()) {
     *html = data.GetHtml();
     *base_url = GURL();
@@ skipping 51 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // OSExchangeData, public:
 
 // static
 OSExchangeData::Provider* OSExchangeData::CreateProvider() {
   return new OSExchangeDataProviderAuraX11();
 }
 
 }  // namespace ui