Convert string16 to base::string16 in content.

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 239 matching lines @@
 
   do {
     unsigned char c = n & 0x7f;
     n >>= 7;
     if (n)
       c |= 0x80;
     into->push_back(c);
   } while (n);
 }
 
-void EncodeString(const string16& value, std::string* into) {
+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));
 
   const char16* src = value.c_str();
   char16* dst = reinterpret_cast<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());
 }
 
-void EncodeStringWithLength(const string16& value, std::string* into) {
+void EncodeStringWithLength(const base::string16& value, std::string* into) {
   EncodeVarInt(value.length(), into);
   EncodeString(value, into);
 }
 
 void EncodeDouble(double value, std::string* into) {
   // This always has host endianness.
   const char* p = reinterpret_cast<char*>(&value);
   into->insert(into->end(), p, p + sizeof(value));
 }
 
@@ skipping 57 matching lines @@
   EncodeByte(kIndexedDBKeyPathTypeCodedByte2, into);
   EncodeByte(static_cast<char>(value.type()), into);
   switch (value.type()) {
     case WebIDBKeyPathTypeNull:
       break;
     case WebIDBKeyPathTypeString: {
       EncodeStringWithLength(value.string(), into);
       break;
     }
     case WebIDBKeyPathTypeArray: {
-      const std::vector<string16>& array = value.array();
+      const std::vector<base::string16>& array = value.array();
       size_t count = array.size();
       EncodeVarInt(count, into);
       for (size_t i = 0; i < count; ++i) {
         EncodeStringWithLength(array[i], into);
       }
       break;
     }
   }
 }
 
@@ skipping 45 matching lines @@
 
     unsigned char c = *it;
     ret |= static_cast<int64>(c & 0x7f) << shift;
     shift += 7;
   } while (*it++ & 0x80);
   *value = ret;
   slice->remove_prefix(it - slice->begin());
   return true;
 }
 
-bool DecodeString(StringPiece* slice, string16* value) {
+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);
-  string16 decoded;
+  base::string16 decoded;
   decoded.reserve(length);
   const char16* encoded = reinterpret_cast<const char16*>(slice->begin());
   for (unsigned i = 0; i < length; ++i)
     decoded.push_back(ntohs(*encoded++));
 
   *value = decoded;
   slice->remove_prefix(length * sizeof(char16));
   return true;
 }
 
-bool DecodeStringWithLength(StringPiece* slice, string16* value) {
+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);
   if (slice->size() < bytes)
     return false;
 
@@ skipping 48 matching lines @@
       return true;
     }
     case kIndexedDBKeyBinaryTypeByte: {
       std::string binary;
       if (!DecodeBinary(slice, &binary))
         return false;
       *value = make_scoped_ptr(new IndexedDBKey(binary));
       return true;
     }
     case kIndexedDBKeyStringTypeByte: {
-      string16 s;
+      base::string16 s;
       if (!DecodeStringWithLength(slice, &s))
         return false;
       *value = make_scoped_ptr(new IndexedDBKey(s));
       return true;
     }
     case kIndexedDBKeyDateTypeByte: {
       double d;
       if (!DecodeDouble(slice, &d))
         return false;
       *value = make_scoped_ptr(new IndexedDBKey(d, WebIDBKeyTypeDate));
@@ skipping 20 matching lines @@
   slice->remove_prefix(sizeof(*value));
   return true;
 }
 
 bool DecodeIDBKeyPath(StringPiece* slice, IndexedDBKeyPath* value) {
   // May be typed, or may be a raw string. An invalid leading
   // byte sequence is used to identify typed coding. New records are
   // always written as typed.
   if (slice->size() < 3 || (*slice)[0] != kIndexedDBKeyPathTypeCodedByte1 ||
       (*slice)[1] != kIndexedDBKeyPathTypeCodedByte2) {
-    string16 s;
+    base::string16 s;
     if (!DecodeString(slice, &s))
       return false;
     *value = IndexedDBKeyPath(s);
     return true;
   }
 
   slice->remove_prefix(2);
   DCHECK(!slice->empty());
   WebIDBKeyPathType type = static_cast<WebIDBKeyPathType>((*slice)[0]);
   slice->remove_prefix(1);
 
   switch (type) {
     case WebIDBKeyPathTypeNull:
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath();
       return true;
     case WebIDBKeyPathTypeString: {
-      string16 string;
+      base::string16 string;
       if (!DecodeStringWithLength(slice, &string))
         return false;
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath(string);
       return true;
     }
     case WebIDBKeyPathTypeArray: {
-      std::vector<string16> array;
+      std::vector<base::string16> array;
       int64 count;
       if (!DecodeVarInt(slice, &count))
         return false;
       DCHECK_GE(count, 0);
       while (count--) {
-        string16 string;
+        base::string16 string;
         if (!DecodeStringWithLength(slice, &string))
           return false;
         array.push_back(string);
       }
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath(array);
       return true;
     }
   }
   NOTREACHED();
@@ skipping 720 matching lines @@
     return false;
   DCHECK_EQ(type_byte, kDatabaseNameTypeByte);
   if (!DecodeStringWithLength(slice, &result->origin_))
     return false;
   if (!DecodeStringWithLength(slice, &result->database_name_))
     return false;
   return true;
 }
 
 std::string DatabaseNameKey::Encode(const std::string& origin_identifier,
-                                    const string16& database_name) {
+                                    const base::string16& database_name) {
   std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kDatabaseNameTypeByte);
   EncodeStringWithLength(base::ASCIIToUTF16(origin_identifier), &ret);
   EncodeStringWithLength(database_name, &ret);
   return ret;
 }
 
 std::string DatabaseNameKey::EncodeMinKeyForOrigin(
     const std::string& origin_identifier) {
-  return Encode(origin_identifier, string16());
+  return Encode(origin_identifier, base::string16());
 }
 
 std::string DatabaseNameKey::EncodeStopKeyForOrigin(
     const std::string& origin_identifier) {
   // just after origin in collation order
   return EncodeMinKeyForOrigin(origin_identifier + '\x01');
 }
 
 int DatabaseNameKey::Compare(const DatabaseNameKey& other) {
   if (int x = origin_.compare(other.origin_))
@@ skipping 249 matching lines @@
   DCHECK(!prefix.index_id_);
   unsigned char type_byte = 0;
   if (!DecodeByte(slice, &type_byte))
     return false;
   DCHECK_EQ(type_byte, kObjectStoreNamesTypeByte);
   if (!DecodeStringWithLength(slice, &result->object_store_name_))
     return false;
   return true;
 }
 
-std::string ObjectStoreNamesKey::Encode(int64 database_id,
-                                        const string16& object_store_name) {
+std::string ObjectStoreNamesKey::Encode(
+    int64 database_id,
+    const base::string16& object_store_name) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreNamesTypeByte);
   EncodeStringWithLength(object_store_name, &ret);
   return ret;
 }
 
 int ObjectStoreNamesKey::Compare(const ObjectStoreNamesKey& other) {
   return object_store_name_.compare(other.object_store_name_);
 }
@@ skipping 15 matching lines @@
   DCHECK_EQ(type_byte, kIndexNamesKeyTypeByte);
   if (!DecodeVarInt(slice, &result->object_store_id_))
     return false;
   if (!DecodeStringWithLength(slice, &result->index_name_))
     return false;
   return true;
 }
 
 std::string IndexNamesKey::Encode(int64 database_id,
                                   int64 object_store_id,
-                                  const string16& index_name) {
+                                  const base::string16& index_name) {
   KeyPrefix prefix(database_id);
   std::string ret = prefix.Encode();
   ret.push_back(kIndexNamesKeyTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeStringWithLength(index_name, &ret);
   return ret;
 }
 
 int IndexNamesKey::Compare(const IndexNamesKey& other) {
   DCHECK_GE(object_store_id_, 0);
@@ skipping 243 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