webkit: use string16 in webkit_glue.h

webkit/glue/webkit_glue.cc

 // Copyright (c) 2010 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 <objidl.h>
 #include <mlang.h>
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
@@ skipping 104 matching lines @@
   }
 
   return result;
 }
 
 string16 DumpRenderer(WebFrame* web_frame) {
   return web_frame->renderTreeAsText();
 }
 
 bool CounterValueForElementById(WebFrame* web_frame, const std::string& id,
-                                std::wstring* counter_value) {
+                                string16* counter_value) {
   WebString result =
       web_frame->counterValueForElementById(WebString::fromUTF8(id));
   if (result.isNull())
     return false;
 
-  *counter_value = UTF16ToWideHack(result);
+  *counter_value = result;
   return true;
 }
 
 int PageNumberForElementById(WebFrame* web_frame,
                              const std::string& id,
                              float page_width_in_pixels,
                              float page_height_in_pixels) {
   return web_frame->pageNumberForElementById(WebString::fromUTF8(id),
                                              page_width_in_pixels,
                                              page_height_in_pixels);
 }
 
 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));
   int number_of_pages = web_frame->printBegin(size);
   web_frame->printEnd();
   return number_of_pages;
 }
 
-std::wstring DumpFrameScrollPosition(WebFrame* web_frame, bool recursive) {
+string16 DumpFrameScrollPosition(WebFrame* web_frame, bool recursive) {
   gfx::Size offset = web_frame->scrollOffset();
-  std::wstring result;
+  std::string result_utf8;
 
   if (offset.width() > 0 || offset.height() > 0) {
     if (web_frame->parent()) {
-      base::StringAppendF(&result, L"frame '%ls' ", UTF16ToWide(
-          web_frame->name()).c_str());
+      base::StringAppendF(&result_utf8, "frame '%s' ",
+                          UTF16ToUTF8(web_frame->name()).c_str());
     }
-    base::StringAppendF(&result, L"scrolled to %d,%d\n",
+    base::StringAppendF(&result_utf8, "scrolled to %d,%d\n",
                         offset.width(), offset.height());
   }
 
+  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();
   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 string in a readable format.
-static std::wstring DumpHistoryItem(const WebHistoryItem& item,
-                                    int indent, bool is_current) {
-  std::wstring result;
+// 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) {

[viettrungluu, 2010/12/14 01:22:18]

Nit: realign indentation.

+  std::string result;
 
   if (is_current) {
-    result.append(L"curr->");
-    result.append(indent - 6, L' ');  // 6 == L"curr->".length()
+    result.append("curr->");
+    result.append(indent - 6, ' ');  // 6 == "curr->".length()
   } else {
-    result.append(indent, L' ');
+    result.append(indent, ' ');
   }
 
   std::string url = item.urlString().utf8();
   size_t pos;
   if (url.find(kFileUrlPattern) == 0 &&
       ((pos = url.find(kLayoutTestsPattern)) != std::string::npos)) {
     // adjust file URLs to match upstream results.
     url.replace(0, pos + kLayoutTestsPatternSize, kFileTestPrefix);
   } else if (url.find(kDataUrlPattern) == 0) {
     // URL-escape data URLs to match results upstream.
     std::string path = EscapePath(url.substr(kDataUrlPatternSize));
     url.replace(kDataUrlPatternSize, url.length(), path);
   }
 
-  result.append(UTF8ToWide(url));
+  result.append(url);
   if (!item.target().isEmpty())
-    result.append(L" (in frame \"" + UTF16ToWide(item.target()) + L"\")");
+    result.append(" (in frame \"" + UTF16ToUTF8(item.target()) + "\")");
   if (item.isTargetItem())
-    result.append(L"  **nav target**");
-  result.append(L"\n");
+    result.append("  **nav target**");
+  result.append("\n");
 
   const WebVector<WebHistoryItem>& children = item.children();
   if (!children.isEmpty()) {
     // Must sort to eliminate arbitrary result ordering which defeats
     // reproducible testing.
     // TODO(darin): WebVector should probably just be a std::vector!!
     std::vector<WebHistoryItem> sorted_children;
     for (size_t i = 0; i < children.size(); ++i)
       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;
 }
 
-std::wstring DumpHistoryState(const std::string& history_state, int indent,
-                              bool is_current) {
-  return DumpHistoryItem(HistoryItemFromString(history_state), indent,
-                         is_current);
+string16 DumpHistoryState(const std::string& history_state, int indent,
+                          bool is_current) {
+  return UTF8ToUTF16(
+      DumpHistoryItem(HistoryItemFromString(history_state), indent,
+                      is_current));
 }
 
 void ResetBeforeTestRun(WebView* view) {
   WebFrame* web_frame = view->mainFrame();
 
   // Reset the main frame name since tests always expect it to be empty.  It
   // is normally not reset between page loads (even in IE and FF).
   if (web_frame)
     web_frame->setName(WebString());
 
@@ skipping 168 matching lines @@
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 int GetGlyphPageCount() {
   return WebGlyphCache::pageCount();
 }
 
 } // namespace webkit_glue