Convert string16 to base::string16 in content.

content/renderer/renderer_clipboard_client.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.
 
 // This file provides the embedder's side of the Clipboard interface.
 
 #include "content/renderer/renderer_clipboard_client.h"
 
 #include "base/memory/shared_memory.h"
 #include "base/strings/string16.h"
@@ skipping 102 matching lines @@
   bool result;
   RenderThreadImpl::current()->Send(
       new ClipboardHostMsg_IsFormatAvailable(format, type, &result));
   return result;
 }
 
 void RendererClipboardClient::Clear(ui::ClipboardType type) {
   RenderThreadImpl::current()->Send(new ClipboardHostMsg_Clear(type));
 }
 
-void RendererClipboardClient::ReadAvailableTypes(ui::ClipboardType type,
-                                                 std::vector<string16>* types,
-                                                 bool* contains_filenames) {
+void RendererClipboardClient::ReadAvailableTypes(
+    ui::ClipboardType type,
+    std::vector<base::string16>* types,
+    bool* contains_filenames) {
   RenderThreadImpl::current()->Send(new ClipboardHostMsg_ReadAvailableTypes(
       type, types, contains_filenames));
 }
 
 void RendererClipboardClient::ReadText(ui::ClipboardType type,
-                                       string16* result) {
+                                       base::string16* result) {
   RenderThreadImpl::current()->Send(
       new ClipboardHostMsg_ReadText(type, result));
 }
 
 void RendererClipboardClient::ReadAsciiText(ui::ClipboardType type,
                                             std::string* result) {
   RenderThreadImpl::current()->Send(
       new ClipboardHostMsg_ReadAsciiText(type, result));
 }
 
 void RendererClipboardClient::ReadHTML(ui::ClipboardType type,
-                                       string16* markup,
+                                       base::string16* markup,
                                        GURL* url, uint32* fragment_start,
                                        uint32* fragment_end) {
   RenderThreadImpl::current()->Send(new ClipboardHostMsg_ReadHTML(
       type, markup, url, fragment_start, fragment_end));
 }
 
 void RendererClipboardClient::ReadRTF(ui::ClipboardType type,
                                       std::string* result) {
   RenderThreadImpl::current()->Send(new ClipboardHostMsg_ReadRTF(type, result));
 }
 
 void RendererClipboardClient::ReadImage(ui::ClipboardType type,
                                         std::string* data) {
   base::SharedMemoryHandle image_handle;
   uint32 image_size;
   RenderThreadImpl::current()->Send(
       new ClipboardHostMsg_ReadImage(type, &image_handle, &image_size));
   if (base::SharedMemory::IsHandleValid(image_handle)) {
     base::SharedMemory buffer(image_handle, true);
     buffer.Map(image_size);
     data->append(static_cast<char*>(buffer.memory()), image_size);
   }
 }
 
 void RendererClipboardClient::ReadCustomData(ui::ClipboardType clipboard_type,
-                                             const string16& type,
-                                             string16* data) {
+                                             const base::string16& type,
+                                             base::string16* data) {
   RenderThreadImpl::current()->Send(
       new ClipboardHostMsg_ReadCustomData(clipboard_type, type, data));
 }
 
 void RendererClipboardClient::ReadData(const ui::Clipboard::FormatType& format,
                                        std::string* data) {
   RenderThreadImpl::current()->Send(
       new ClipboardHostMsg_ReadData(format, data));
 }
 
 ClipboardClient::WriteContext* RendererClipboardClient::CreateWriteContext() {
   return new RendererClipboardWriteContext;
 }
 
 }  // namespace content