Update from https://crrev.com/320343

base/pickle.cc

 // Copyright (c) 2012 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 "base/pickle.h"
 
 #include <stdlib.h>
 
 #include <algorithm>  // for max()
 
@@ skipping 134 matching lines @@
   if (!ReadInt(&len))
     return false;
   const char* read_from = GetReadPointerAndAdvance(len);
   if (!read_from)
     return false;
 
   result->assign(read_from, len);
   return true;
 }
 
-bool PickleIterator::ReadWString(std::wstring* result) {
+bool PickleIterator::ReadStringPiece(base::StringPiece* result) {
   int len;
   if (!ReadInt(&len))
     return false;
-  const char* read_from = GetReadPointerAndAdvance(len, sizeof(wchar_t));
+  const char* read_from = GetReadPointerAndAdvance(len);
   if (!read_from)
     return false;
 
-  result->assign(reinterpret_cast<const wchar_t*>(read_from), len);
+  *result = base::StringPiece(read_from, len);
   return true;
 }
 
 bool PickleIterator::ReadString16(string16* result) {
   int len;
   if (!ReadInt(&len))
     return false;
   const char* read_from = GetReadPointerAndAdvance(len, sizeof(char16));
   if (!read_from)
     return false;
 
   result->assign(reinterpret_cast<const char16*>(read_from), len);
   return true;
 }
 
+bool PickleIterator::ReadStringPiece16(base::StringPiece16* result) {
+  int len;
+  if (!ReadInt(&len))
+    return false;
+  const char* read_from = GetReadPointerAndAdvance(len, sizeof(char16));
+  if (!read_from)
+    return false;
+
+  *result = base::StringPiece16(reinterpret_cast<const char16*>(read_from),
+                                len);
+  return true;
+}
+
 bool PickleIterator::ReadData(const char** data, int* length) {
   *length = 0;
   *data = 0;
 
   if (!ReadInt(length))
     return false;
 
   return ReadBytes(data, *length);
 }
 
@@ skipping 75 matching lines @@
     header_ = NULL;
     header_size_ = other.header_size_;
   }
   Resize(other.header_->payload_size);
   memcpy(header_, other.header_,
          other.header_size_ + other.header_->payload_size);
   write_offset_ = other.write_offset_;
   return *this;
 }
 
-bool Pickle::WriteString(const std::string& value) {
+bool Pickle::WriteString(const base::StringPiece& value) {
   if (!WriteInt(static_cast<int>(value.size())))
     return false;
 
   return WriteBytes(value.data(), static_cast<int>(value.size()));
 }
 
-bool Pickle::WriteWString(const std::wstring& value) {
+bool Pickle::WriteString16(const base::StringPiece16& value) {
   if (!WriteInt(static_cast<int>(value.size())))
     return false;
 
-  return WriteBytes(value.data(),
-                    static_cast<int>(value.size() * sizeof(wchar_t)));
-}
-
-bool Pickle::WriteString16(const string16& value) {
-  if (!WriteInt(static_cast<int>(value.size())))
-    return false;
-
   return WriteBytes(value.data(),
                     static_cast<int>(value.size()) * sizeof(char16));
 }
 
 bool Pickle::WriteData(const char* data, int length) {
   return length >= 0 && WriteInt(length) && WriteBytes(data, length);
 }
 
 bool Pickle::WriteBytes(const void* data, int length) {
   WriteBytesCommon(data, length);
@@ skipping 60 matching lines @@
   if (new_size > capacity_after_header_) {
     Resize(std::max(capacity_after_header_ * 2, new_size));
   }
 
   char* write = mutable_payload() + write_offset_;
   memcpy(write, data, length);
   memset(write + length, 0, data_len - length);
   header_->payload_size = static_cast<uint32>(new_size);
   write_offset_ = new_size;
 }