Convert string16 to base::string16 in content.

content/browser/indexed_db/indexed_db_leveldb_coding.h

 // 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.
 
 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 
 namespace content {
 
 CONTENT_EXPORT extern const unsigned char kMinimumIndexId;
 
 CONTENT_EXPORT std::string MaxIDBKey();
 CONTENT_EXPORT std::string MinIDBKey();
 
 CONTENT_EXPORT void EncodeByte(unsigned char value, std::string* into);
 CONTENT_EXPORT void EncodeBool(bool value, std::string* into);
 CONTENT_EXPORT void EncodeInt(int64 value, std::string* into);
 CONTENT_EXPORT void EncodeVarInt(int64 value, std::string* into);
-CONTENT_EXPORT void EncodeString(const string16& value, std::string* into);
-CONTENT_EXPORT void EncodeStringWithLength(const string16& value,
+CONTENT_EXPORT void EncodeString(const base::string16& value,
+                                 std::string* into);
+CONTENT_EXPORT void EncodeStringWithLength(const base::string16& value,
                                            std::string* into);
 CONTENT_EXPORT void EncodeBinary(const std::string& value, std::string* into);
 CONTENT_EXPORT void EncodeDouble(double value, std::string* into);
 CONTENT_EXPORT void EncodeIDBKey(const IndexedDBKey& value, std::string* into);
 CONTENT_EXPORT void EncodeIDBKeyPath(const IndexedDBKeyPath& value,
                                      std::string* into);
 
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeByte(base::StringPiece* slice,
                                                   unsigned char* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeBool(base::StringPiece* slice,
                                                   bool* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeInt(base::StringPiece* slice,
                                                  int64* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeVarInt(base::StringPiece* slice,
                                                     int64* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeString(base::StringPiece* slice,
-                                                    string16* value);
+                                                    base::string16* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeStringWithLength(
     base::StringPiece* slice,
-    string16* value);
+    base::string16* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeBinary(base::StringPiece* slice,
                                                     std::string* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeDouble(base::StringPiece* slice,
                                                     double* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeIDBKey(
     base::StringPiece* slice,
     scoped_ptr<IndexedDBKey>* value);
 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeIDBKeyPath(
     base::StringPiece* slice,
     IndexedDBKeyPath* value);
@@ skipping 119 matching lines @@
   int Compare(const DatabaseFreeListKey& other) const;
 
  private:
   int64 database_id_;
 };
 
 class DatabaseNameKey {
  public:
   static bool Decode(base::StringPiece* slice, DatabaseNameKey* result);
   CONTENT_EXPORT static std::string Encode(const std::string& origin_identifier,
-                                           const string16& database_name);
+                                           const base::string16& database_name);
   static std::string EncodeMinKeyForOrigin(
       const std::string& origin_identifier);
   static std::string EncodeStopKeyForOrigin(
       const std::string& origin_identifier);
-  string16 origin() const { return origin_; }
-  string16 database_name() const { return database_name_; }
+  base::string16 origin() const { return origin_; }
+  base::string16 database_name() const { return database_name_; }
   int Compare(const DatabaseNameKey& other);
 
  private:
-  string16 origin_;  // TODO(jsbell): Store encoded strings, or just pointers.
-  string16 database_name_;
+  base::string16 origin_;  // TODO(jsbell): Store encoded strings, or just
+                           // pointers.
+  base::string16 database_name_;
 };
 
 class DatabaseMetaDataKey {
  public:
   enum MetaDataType {
     ORIGIN_NAME = 0,
     DATABASE_NAME = 1,
     USER_VERSION = 2,
     MAX_OBJECT_STORE_ID = 3,
     USER_INT_VERSION = 4,
@@ skipping 95 matching lines @@
   int64 object_store_id_;
   int64 index_id_;
 };
 
 class ObjectStoreNamesKey {
  public:
   // TODO(jsbell): We never use this to look up object store ids,
   // because a mapping is kept in the IndexedDBDatabase. Can the
   // mapping become unreliable?  Can we remove this?
   static bool Decode(base::StringPiece* slice, ObjectStoreNamesKey* result);
-  CONTENT_EXPORT static std::string Encode(int64 database_id,
-                                           const string16& object_store_name);
+  CONTENT_EXPORT static std::string Encode(
+      int64 database_id,
+      const base::string16& object_store_name);
   int Compare(const ObjectStoreNamesKey& other);
-  string16 object_store_name() const { return object_store_name_; }
+  base::string16 object_store_name() const { return object_store_name_; }
 
  private:
   // TODO(jsbell): Store the encoded string, or just pointers to it.
-  string16 object_store_name_;
+  base::string16 object_store_name_;
 };
 
 class IndexNamesKey {
  public:
   IndexNamesKey();
   // TODO(jsbell): We never use this to look up index ids, because a mapping
   // is kept at a higher level.
   static bool Decode(base::StringPiece* slice, IndexNamesKey* result);
   CONTENT_EXPORT static std::string Encode(int64 database_id,
                                            int64 object_store_id,
-                                           const string16& index_name);
+                                           const base::string16& index_name);
   int Compare(const IndexNamesKey& other);
-  string16 index_name() const { return index_name_; }
+  base::string16 index_name() const { return index_name_; }
 
  private:
   int64 object_store_id_;
-  string16 index_name_;
+  base::string16 index_name_;
 };
 
 class ObjectStoreDataKey {
  public:
   static bool Decode(base::StringPiece* slice, ObjectStoreDataKey* result);
   CONTENT_EXPORT static std::string Encode(int64 database_id,
                                            int64 object_store_id,
                                            const std::string encoded_user_key);
   static std::string Encode(int64 database_id,
                             int64 object_store_id,
@@ skipping 73 matching lines @@
   std::string encoded_user_key_;
   std::string encoded_primary_key_;
   int64 sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexDataKey);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_