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

content/browser/indexed_db/indexed_db_leveldb_coding.cc

 // Copyright (c) 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/browser/indexed_db/indexed_db_leveldb_coding.h"
 
 #include <iterator>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 245 matching lines @@
     into->push_back(c);
   } while (n);
 }
 
 void EncodeString(const base::string16& value, std::string* into) {
   if (value.empty())
     return;
   // Backing store is UTF-16BE, convert from host endianness.
   size_t length = value.length();
   size_t current = into->size();
-  into->resize(into->size() + length * sizeof(char16));
+  into->resize(into->size() + length * sizeof(base::char16));
 
-  const char16* src = value.c_str();
-  char16* dst = reinterpret_cast<char16*>(&*into->begin() + current);
+  const base::char16* src = value.c_str();
+  base::char16* dst =
+      reinterpret_cast<base::char16*>(&*into->begin() + current);
   for (unsigned i = 0; i < length; ++i)
     *dst++ = htons(*src++);
 }
 
 void EncodeBinary(const std::string& value, std::string* into) {
   EncodeVarInt(value.length(), into);
   into->append(value.begin(), value.end());
   DCHECK(into->size() >= value.size());
 }
 
@@ skipping 141 matching lines @@
   return true;
 }
 
 bool DecodeString(StringPiece* slice, base::string16* value) {
   if (slice->empty()) {
     value->clear();
     return true;
   }
 
   // Backing store is UTF-16BE, convert to host endianness.
-  DCHECK(!(slice->size() % sizeof(char16)));
-  size_t length = slice->size() / sizeof(char16);
+  DCHECK(!(slice->size() % sizeof(base::char16)));
+  size_t length = slice->size() / sizeof(base::char16);
   base::string16 decoded;
   decoded.reserve(length);
-  const char16* encoded = reinterpret_cast<const char16*>(slice->begin());
+  const base::char16* encoded =
+      reinterpret_cast<const base::char16*>(slice->begin());
   for (unsigned i = 0; i < length; ++i)
     decoded.push_back(ntohs(*encoded++));
 
   *value = decoded;
-  slice->remove_prefix(length * sizeof(char16));
+  slice->remove_prefix(length * sizeof(base::char16));
   return true;
 }
 
 bool DecodeStringWithLength(StringPiece* slice, base::string16* value) {
   if (slice->empty())
     return false;
 
   int64 length = 0;
   if (!DecodeVarInt(slice, &length) || length < 0)
     return false;
-  size_t bytes = length * sizeof(char16);
+  size_t bytes = length * sizeof(base::char16);
   if (slice->size() < bytes)
     return false;
 
   StringPiece subpiece(slice->begin(), bytes);
   slice->remove_prefix(bytes);
   if (!DecodeString(&subpiece, value))
     return false;
 
   return true;
 }
@@ skipping 159 matching lines @@
         return false;
       if (slice->size() < static_cast<size_t>(length))
         return false;
       slice->remove_prefix(length);
       return true;
     }
     case kIndexedDBKeyStringTypeByte: {
       int64 length = 0;
       if (!DecodeVarInt(slice, &length) || length < 0)
         return false;
-      if (slice->size() < static_cast<size_t>(length) * sizeof(char16))
+      if (slice->size() < static_cast<size_t>(length) * sizeof(base::char16))
         return false;
-      slice->remove_prefix(length * sizeof(char16));
+      slice->remove_prefix(length * sizeof(base::char16));
       return true;
     }
     case kIndexedDBKeyDateTypeByte:
     case kIndexedDBKeyNumberTypeByte:
       if (slice->size() < sizeof(double))
         return false;
       slice->remove_prefix(sizeof(double));
       return true;
   }
   NOTREACHED();
@@ skipping 39 matching lines @@
   if (!DecodeVarInt(slice1, &len1) || !DecodeVarInt(slice2, &len2)) {
     *ok = false;
     return 0;
   }
   DCHECK_GE(len1, 0);
   DCHECK_GE(len2, 0);
   if (len1 < 0 || len2 < 0) {
     *ok = false;
     return 0;
   }
-  DCHECK_GE(slice1->size(), len1 * sizeof(char16));
-  DCHECK_GE(slice2->size(), len2 * sizeof(char16));
-  if (slice1->size() < len1 * sizeof(char16) ||
-      slice2->size() < len2 * sizeof(char16)) {
+  DCHECK_GE(slice1->size(), len1 * sizeof(base::char16));
+  DCHECK_GE(slice2->size(), len2 * sizeof(base::char16));
+  if (slice1->size() < len1 * sizeof(base::char16) ||
+      slice2->size() < len2 * sizeof(base::char16)) {
     *ok = false;
     return 0;
   }
 
   // Extract the string data, and advance the passed slices.
-  StringPiece string1(slice1->begin(), len1 * sizeof(char16));
-  StringPiece string2(slice2->begin(), len2 * sizeof(char16));
-  slice1->remove_prefix(len1 * sizeof(char16));
-  slice2->remove_prefix(len2 * sizeof(char16));
+  StringPiece string1(slice1->begin(), len1 * sizeof(base::char16));
+  StringPiece string2(slice2->begin(), len2 * sizeof(base::char16));
+  slice1->remove_prefix(len1 * sizeof(base::char16));
+  slice2->remove_prefix(len2 * sizeof(base::char16));
 
   *ok = true;
   // Strings are UTF-16BE encoded, so a simple memcmp is sufficient.
   return string1.compare(string2);
 }
 
 int CompareEncodedBinary(StringPiece* slice1,
                          StringPiece* slice2,
                          bool* ok) {
   int64 len1, len2;
@@ skipping 1155 matching lines @@
 scoped_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_primary_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
 }  // namespace content