Fix localstorage data migration.

content/browser/dom_storage/local_storage_context_mojo.cc

 // Copyright 2016 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/dom_storage/local_storage_context_mojo.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/leveldb/public/cpp/util.h"
@@ skipping 50 matching lines @@
   auto serialized_origin = leveldb::StdStringToUint8Vector(origin.Serialize());
   std::vector<uint8_t> key;
   key.reserve(arraysize(kMetaPrefix) + serialized_origin.size());
   key.insert(key.end(), kMetaPrefix, kMetaPrefix + arraysize(kMetaPrefix));
   key.insert(key.end(), serialized_origin.begin(), serialized_origin.end());
   return key;
 }
 
 void NoOpSuccess(bool success) {}
 
-std::vector<uint8_t> String16ToUint8Vector(const base::string16& input) {
-  const uint8_t* data = reinterpret_cast<const uint8_t*>(input.data());
-  return std::vector<uint8_t>(data, data + input.size() * sizeof(base::char16));
-}
-
 void MigrateStorageHelper(
     base::FilePath db_path,
     const scoped_refptr<base::SingleThreadTaskRunner> reply_task_runner,
     base::Callback<void(std::unique_ptr<LevelDBWrapperImpl::ValueMap>)>
         callback) {
   DOMStorageDatabase db(db_path);
   DOMStorageValuesMap map;
   db.ReadAllValues(&map);
   auto values = base::MakeUnique<LevelDBWrapperImpl::ValueMap>();
   for (const auto& it : map) {
-    (*values)[String16ToUint8Vector(it.first)] =
-        String16ToUint8Vector(it.second.string());
+    (*values)[LocalStorageContextMojo::MigrateString(it.first)] =
+        LocalStorageContextMojo::MigrateString(it.second.string());
   }
   reply_task_runner->PostTask(FROM_HERE,
                               base::Bind(callback, base::Passed(&values)));
 }
 
 // Helper to convert from OnceCallback to Callback.
 void CallMigrationCalback(LevelDBWrapperImpl::ValueMapCallback callback,
                           std::unique_ptr<LevelDBWrapperImpl::ValueMap> data) {
   std::move(callback).Run(std::move(data));
 }
@@ skipping 190 matching lines @@
 leveldb::mojom::LevelDBDatabaseAssociatedRequest
 LocalStorageContextMojo::DatabaseRequestForTesting() {
   DCHECK_EQ(connection_state_, NO_CONNECTION);
   connection_state_ = CONNECTION_IN_PROGRESS;
   leveldb::mojom::LevelDBDatabaseAssociatedRequest request =
       MakeIsolatedRequest(&database_);
   OnDatabaseOpened(true, leveldb::mojom::DatabaseError::OK);
   return request;
 }
 
+// static
+std::vector<uint8_t> LocalStorageContextMojo::MigrateString(
+    const base::string16& input) {
+  static const uint8_t kUTF16Format = 0;
+
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(input.data());
+  std::vector<uint8_t> result;
+  result.reserve(input.size() * sizeof(base::char16) + 1);
+  result.push_back(kUTF16Format);
+  result.insert(result.end(), data, data + input.size() * sizeof(base::char16));
+  return result;
+}
+
 void LocalStorageContextMojo::RunWhenConnected(base::OnceClosure callback) {
   // If we don't have a filesystem_connection_, we'll need to establish one.
   if (connection_state_ == NO_CONNECTION) {
     CHECK(connector_);
     file_service_connection_ = connector_->Connect(file::mojom::kServiceName);
     connection_state_ = CONNECTION_IN_PROGRESS;
     file_service_connection_->AddConnectionCompletedClosure(
         base::Bind(&LocalStorageContextMojo::OnUserServiceConnectionComplete,
                    weak_ptr_factory_.GetWeakPtr()));
     file_service_connection_->SetConnectionLostClosure(
@@ skipping 281 matching lines @@
   for (const auto& info : usage) {
     url::Origin origin_candidate(info.origin);
     if (!origin_candidate.IsSameOriginWith(origin) &&
         origin_candidate.IsSamePhysicalOriginWith(origin))
       DeleteStorage(origin_candidate);
   }
   DeleteStorage(origin);
 }
 
 }  // namespace content