Change UTF8ToUTF16 to accept const StringPiece&.

base/string_piece.h

 // Copyright (c) 2011 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.
 // Copied from strings/stringpiece.h with modifications
 //
 // A string-like object that points to a sized piece of memory.
 //
 // Functions or methods may use const StringPiece& parameters to accept either
 // a "const char*" or a "string" value that will be implicitly converted to
 // a StringPiece.  The implicit conversion means that it is often appropriate
 // to include this .h file in other files rather than forward-declaring
 // StringPiece as would be appropriate for most other Google classes.
 //
 // Systematic usage of StringPiece is encouraged as it will reduce unnecessary
 // conversions from "const char*" to "string" and back again.
 //
 
 #ifndef BASE_STRING_PIECE_H_
 #define BASE_STRING_PIECE_H_
 #pragma once
 
-#include <algorithm>
-#include <iosfwd>
 #include <string>
 
 #include "base/basictypes.h"
 
 namespace base {
 
 class StringPiece {
  public:
   // standard STL container boilerplate
   typedef size_t size_type;
@@ skipping 52 matching lines @@
   void remove_prefix(size_type n) {
     ptr_ += n;
     length_ -= n;
   }
 
   void remove_suffix(size_type n) {
     length_ -= n;
   }
 
   int compare(const StringPiece& x) const {
-    int r = wordmemcmp(ptr_, x.ptr_, std::min(length_, x.length_));
+    int r = wordmemcmp(
+        ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
     if (r == 0) {
       if (length_ < x.length_) r = -1;
       else if (length_ > x.length_) r = +1;
     }
     return r;
   }
 
   std::string as_string() const {
     // std::string doesn't like to take a NULL pointer even with a 0 size.
     return std::string(!empty() ? data() : "", size());
@@ skipping 57 matching lines @@
   size_type     length_;
 };
 
 bool operator==(const StringPiece& x, const StringPiece& y);
 
 inline bool operator!=(const StringPiece& x, const StringPiece& y) {
   return !(x == y);
 }
 
 inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  const int r = StringPiece::wordmemcmp(x.data(), y.data(),
-                                        std::min(x.size(), y.size()));
+  const int r = StringPiece::wordmemcmp(
+      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
   return ((r < 0) || ((r == 0) && (x.size() < y.size())));
 }
 
 inline bool operator>(const StringPiece& x, const StringPiece& y) {
   return y < x;
 }
 
 inline bool operator<=(const StringPiece& x, const StringPiece& y) {
   return !(x > y);
 }
 
 inline bool operator>=(const StringPiece& x, const StringPiece& y) {
   return !(x < y);
 }
 
-// allow StringPiece to be logged (needed for unit testing).
-extern std::ostream& operator<<(std::ostream& o, const StringPiece& piece);
-
 }  // namespace base
 
 #endif  // BASE_STRING_PIECE_H_