Switch database/file_identifier to std::string, remove createFromDatabaseIdentifier calls

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 <string>
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "content/browser/indexed_db/leveldb/leveldb_slice.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "third_party/WebKit/public/platform/WebIDBKeyPath.h"
 
 // LevelDB stores key/value pairs. Keys and values are strings of bytes,
 // normally of type std::vector<char>.
 //
 // The keys in the backing store are variable-length tuples with different types
@@ skipping 1247 matching lines @@
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kDatabaseNameTypeByte);
   if (!DecodeStringWithLength(&slice, &result->origin_))
     return 0;
   if (!DecodeStringWithLength(&slice, &result->database_name_))
     return 0;
   return slice.begin();
 }
 
-std::vector<char> DatabaseNameKey::Encode(const string16& origin,
+std::vector<char> DatabaseNameKey::Encode(const std::string& origin_identifier,
                                           const string16& database_name) {
   std::vector<char> ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kDatabaseNameTypeByte);
-  EncodeStringWithLength(origin, &ret);
+  EncodeStringWithLength(base::ASCIIToUTF16(origin_identifier), &ret);
   EncodeStringWithLength(database_name, &ret);
   return ret;
 }
 
 std::vector<char> DatabaseNameKey::EncodeMinKeyForOrigin(
-    const string16& origin) {
-  return Encode(origin, string16());
+    const std::string& origin_identifier) {
+  return Encode(origin_identifier, string16());
 }
 
 std::vector<char> DatabaseNameKey::EncodeStopKeyForOrigin(
-    const string16& origin) {
+    const std::string& origin_identifier) {
   // just after origin in collation order
-  return EncodeMinKeyForOrigin(origin + base::char16('\x01'));
+  return EncodeMinKeyForOrigin(origin_identifier + '\x01');
 }
 
 int DatabaseNameKey::Compare(const DatabaseNameKey& other) {
   if (int x = origin_.compare(other.origin_))
     return x;
   return database_name_.compare(other.database_name_);
 }
 
 std::vector<char> DatabaseMetaDataKey::Encode(int64 database_id,
                                               MetaDataType meta_data_type) {
@@ skipping 582 matching lines @@
 scoped_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(&encoded_primary_key_[0], encoded_primary_key_.size());
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
 }  // namespace content