Update some uses of char16 to use the base:: namespace.

content/common/page_state_serialization.cc

 // Copyright 2013 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 "content/common/page_state_serialization.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/pickle.h"
@@ skipping 293 matching lines @@
   return std::string();
 }
 
 // WriteString pickles the NullableString16 as <int length><char16* data>.
 // If length == -1, then the NullableString16 itself is null.  Otherwise the
 // length is the number of char16 (not bytes) in the NullableString16.
 void WriteString(const base::NullableString16& str, SerializeObject* obj) {
   if (str.is_null()) {
     obj->pickle.WriteInt(-1);
   } else {
-    const char16* data = str.string().data();
-    size_t length_in_bytes = str.string().length() * sizeof(char16);
+    const base::char16* data = str.string().data();
+    size_t length_in_bytes = str.string().length() * sizeof(base::char16);
 
     CHECK_LT(length_in_bytes,
              static_cast<size_t>(std::numeric_limits<int>::max()));
     obj->pickle.WriteInt(length_in_bytes);
     obj->pickle.WriteBytes(data, length_in_bytes);
   }
 }
 
 // This reads a serialized NullableString16 from obj. If a string can't be
 // read, NULL is returned.
-const char16* ReadStringNoCopy(SerializeObject* obj, int* num_chars) {
+const base::char16* ReadStringNoCopy(SerializeObject* obj, int* num_chars) {
   int length_in_bytes;
   if (!obj->pickle.ReadInt(&obj->iter, &length_in_bytes)) {
     obj->parse_error = true;
     return NULL;
   }
 
   if (length_in_bytes < 0)
     return NULL;
 
   const char* data;
   if (!obj->pickle.ReadBytes(&obj->iter, &data, length_in_bytes)) {
     obj->parse_error = true;
     return NULL;
   }
 
   if (num_chars)
-    *num_chars = length_in_bytes / sizeof(char16);
-  return reinterpret_cast<const char16*>(data);
+    *num_chars = length_in_bytes / sizeof(base::char16);
+  return reinterpret_cast<const base::char16*>(data);
 }
 
 base::NullableString16 ReadString(SerializeObject* obj) {
   int num_chars;
-  const char16* chars = ReadStringNoCopy(obj, &num_chars);
+  const base::char16* chars = ReadStringNoCopy(obj, &num_chars);
   return chars ?
       base::NullableString16(base::string16(chars, num_chars), false) :
       base::NullableString16();
 }
 
 void ConsumeString(SerializeObject* obj) {
-  const char16* unused ALLOW_UNUSED = ReadStringNoCopy(obj, NULL);
+  const base::char16* unused ALLOW_UNUSED = ReadStringNoCopy(obj, NULL);
 }
 
 template <typename T>
 void WriteAndValidateVectorSize(const std::vector<T>& v, SerializeObject* obj) {
   CHECK_LT(v.size(), std::numeric_limits<int>::max() / sizeof(T));
   WriteInteger(static_cast<int>(v.size()), obj);
 }
 
 size_t ReadAndValidateVectorSize(SerializeObject* obj, size_t element_size) {
   size_t num_elements = static_cast<size_t>(ReadInteger(obj));
@@ skipping 336 matching lines @@
     float device_scale_factor,
     ExplodedPageState* exploded) {
   g_device_scale_factor_for_testing = device_scale_factor;
   bool rv = DecodePageState(encoded, exploded);
   g_device_scale_factor_for_testing = 0.0;
   return rv;
 }
 #endif
 
 }  // namespace content