Replace string16 with base::string16 in src/webkit

webkit/glue/webkit_glue.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 "webkit/glue/webkit_glue.h"
 
 #if defined(OS_WIN)
 #include <mlang.h>
 #include <objidl.h>
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
@@ skipping 83 matching lines @@
 
 void EnableWebCoreLogChannels(const std::string& channels) {
   if (channels.empty())
     return;
   base::StringTokenizer t(channels, ", ");
   while (t.GetNext()) {
     WebKit::enableLogChannel(t.token().c_str());
   }
 }
 
-string16 DumpDocumentText(WebFrame* web_frame) {
+base::string16 DumpDocumentText(WebFrame* web_frame) {
   // We use the document element's text instead of the body text here because
   // not all documents have a body, such as XML documents.
   WebElement document_element = web_frame->document().documentElement();
   if (document_element.isNull())
-    return string16();
+    return base::string16();
 
   return document_element.innerText();
 }
 
-string16 DumpFramesAsText(WebFrame* web_frame, bool recursive) {
-  string16 result;
+base::string16 DumpFramesAsText(WebFrame* web_frame, bool recursive) {
+  base::string16 result;
 
   // Add header for all but the main frame. Skip empty frames.
   if (web_frame->parent() &&
       !web_frame->document().documentElement().isNull()) {
     result.append(ASCIIToUTF16("\n--------\nFrame: '"));
     result.append(web_frame->uniqueName());
     result.append(ASCIIToUTF16("'\n--------\n"));
   }
 
   result.append(DumpDocumentText(web_frame));
   result.append(ASCIIToUTF16("\n"));
 
   if (recursive) {
     WebFrame* child = web_frame->firstChild();
     for (; child; child = child->nextSibling())
       result.append(DumpFramesAsText(child, recursive));
   }
 
   return result;
 }
 
-string16 DumpRenderer(WebFrame* web_frame) {
+base::string16 DumpRenderer(WebFrame* web_frame) {
   return web_frame->renderTreeAsText();
 }
 
 int NumberOfPages(WebFrame* web_frame,
                   float page_width_in_pixels,
                   float page_height_in_pixels) {
   WebSize size(static_cast<int>(page_width_in_pixels),
                static_cast<int>(page_height_in_pixels));
 
   WebPrintParams print_params;
   print_params.paperSize = size;
   print_params.printContentArea = WebRect(0, 0, size.width, size.height);
   print_params.printableArea = WebRect(0, 0, size.width, size.height);
 
   int number_of_pages = web_frame->printBegin(print_params);
   web_frame->printEnd();
   return number_of_pages;
 }
 
-string16 DumpFrameScrollPosition(WebFrame* web_frame, bool recursive) {
+base::string16 DumpFrameScrollPosition(WebFrame* web_frame, bool recursive) {
   gfx::Size offset = web_frame->scrollOffset();
   std::string result_utf8;
 
   if (offset.width() > 0 || offset.height() > 0) {
     if (web_frame->parent()) {
       base::StringAppendF(&result_utf8, "frame '%s' ",
                           UTF16ToUTF8(web_frame->uniqueName()).c_str());
     }
     base::StringAppendF(&result_utf8, "scrolled to %d,%d\n",
                         offset.width(), offset.height());
   }
 
-  string16 result = UTF8ToUTF16(result_utf8);
+  base::string16 result = UTF8ToUTF16(result_utf8);
 
   if (recursive) {
     WebFrame* child = web_frame->firstChild();
     for (; child; child = child->nextSibling())
       result.append(DumpFrameScrollPosition(child, recursive));
   }
 
   return result;
 }
 
 // Returns True if item1 < item2.
 static bool HistoryItemCompareLess(const WebHistoryItem& item1,
                                    const WebHistoryItem& item2) {
-  string16 target1 = item1.target();
-  string16 target2 = item2.target();
+  base::string16 target1 = item1.target();
+  base::string16 target2 = item2.target();
   std::transform(target1.begin(), target1.end(), target1.begin(), tolower);
   std::transform(target2.begin(), target2.end(), target2.begin(), tolower);
   return target1 < target2;
 }
 
 // Writes out a HistoryItem into a UTF-8 string in a readable format.
 static std::string DumpHistoryItem(const WebHistoryItem& item,
                                    int indent, bool is_current) {
   std::string result;
 
@@ skipping 33 matching lines @@
       sorted_children.push_back(children[i]);
     std::sort(sorted_children.begin(), sorted_children.end(),
               HistoryItemCompareLess);
     for (size_t i = 0; i < sorted_children.size(); i++)
       result += DumpHistoryItem(sorted_children[i], indent+4, false);
   }
 
   return result;
 }
 
-string16 DumpHistoryState(const std::string& history_state, int indent,
+base::string16 DumpHistoryState(const std::string& history_state, int indent,
                           bool is_current) {
   return UTF8ToUTF16(
       DumpHistoryItem(HistoryItemFromString(history_state), indent,
                       is_current));
 }
 
 #ifndef NDEBUG
 // The log macro was having problems due to collisions with WTF, so we just
 // code here what that would have inlined.
 void DumpLeakedObject(const char* file, int line, const char* object,
@@ skipping 116 matching lines @@
           base::GetCurrentProcessHandle()));
   return process_metrics->GetPagefileUsage() >> 10;
 }
 #endif
 
 double ZoomFactorToZoomLevel(double factor) {
   return WebView::zoomFactorToZoomLevel(factor);
 }
 
 } // namespace webkit_glue