Update from https://crrev.com/333737

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()
 
-//------------------------------------------------------------------------------
-
-using base::char16;
-using base::string16;
+namespace base {
 
 // static
 const int Pickle::kPayloadUnit = 64;
 
 static const size_t kCapacityReadOnly = static_cast<size_t>(-1);
 
 PickleIterator::PickleIterator(const Pickle& pickle)
     : payload_(pickle.payload()),
       read_index_(0),
       end_index_(pickle.payload_size()) {
@@ skipping 120 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::ReadStringPiece(base::StringPiece* result) {
+bool PickleIterator::ReadStringPiece(StringPiece* result) {
   int len;
   if (!ReadInt(&len))
     return false;
   const char* read_from = GetReadPointerAndAdvance(len);
   if (!read_from)
     return false;
 
-  *result = base::StringPiece(read_from, len);
+  *result = 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) {
+bool PickleIterator::ReadStringPiece16(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);
+  *result = 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;
 
@@ skipping 78 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 base::StringPiece& value) {
+bool Pickle::WriteString(const StringPiece& value) {
   if (!WriteInt(static_cast<int>(value.size())))
     return false;
 
   return WriteBytes(value.data(), static_cast<int>(value.size()));
 }
 
-bool Pickle::WriteString16(const base::StringPiece16& value) {
+bool Pickle::WriteString16(const StringPiece16& 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);
 }
@@ skipping 64 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;
 }
+
+}  // namespace base