Change most uses of Pickle to base::Pickle

storage/browser/fileapi/file_system_usage_cache.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 "storage/browser/fileapi/file_system_usage_cache.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 20 matching lines @@
   CloseCacheFiles();
 }
 
 const base::FilePath::CharType FileSystemUsageCache::kUsageFileName[] =
     FILE_PATH_LITERAL(".usage");
 const char FileSystemUsageCache::kUsageFileHeader[] = "FSU5";
 const int FileSystemUsageCache::kUsageFileHeaderSize = 4;
 
 // Pickle::{Read,Write}Bool treat bool as int
 const int FileSystemUsageCache::kUsageFileSize =
-    sizeof(Pickle::Header) +
-    FileSystemUsageCache::kUsageFileHeaderSize +
+    sizeof(base::Pickle::Header) + FileSystemUsageCache::kUsageFileHeaderSize +
     sizeof(int) + sizeof(int32) + sizeof(int64);  // NOLINT
 
 bool FileSystemUsageCache::GetUsage(const base::FilePath& usage_file_path,
                                     int64* usage_out) {
   TRACE_EVENT0("FileSystem", "UsageCache::GetUsage");
   DCHECK(CalledOnValidThread());
   DCHECK(usage_out);
   bool is_valid = true;
   uint32 dirty = 0;
   int64 usage = 0;
@@ skipping 116 matching lines @@
   TRACE_EVENT0("FileSystem", "UsageCache::Read");
   DCHECK(CalledOnValidThread());
   DCHECK(is_valid);
   DCHECK(dirty_out);
   DCHECK(usage_out);
   char buffer[kUsageFileSize];
   const char *header;
   if (usage_file_path.empty() ||
       !ReadBytes(usage_file_path, buffer, kUsageFileSize))
     return false;
-  Pickle read_pickle(buffer, kUsageFileSize);
-  PickleIterator iter(read_pickle);
+  base::Pickle read_pickle(buffer, kUsageFileSize);
+  base::PickleIterator iter(read_pickle);
   uint32 dirty = 0;
   int64 usage = 0;
 
   if (!iter.ReadBytes(&header, kUsageFileHeaderSize) ||
       !iter.ReadBool(is_valid) ||
       !iter.ReadUInt32(&dirty) ||
       !iter.ReadInt64(&usage))
     return false;
 
   if (header[0] != kUsageFileHeader[0] ||
       header[1] != kUsageFileHeader[1] ||
       header[2] != kUsageFileHeader[2] ||
       header[3] != kUsageFileHeader[3])
     return false;
 
   *dirty_out = dirty;
   *usage_out = usage;
   return true;
 }
 
 bool FileSystemUsageCache::Write(const base::FilePath& usage_file_path,
                                  bool is_valid,
                                  int32 dirty,
                                  int64 usage) {
   TRACE_EVENT0("FileSystem", "UsageCache::Write");
   DCHECK(CalledOnValidThread());
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   write_pickle.WriteBytes(kUsageFileHeader, kUsageFileHeaderSize);
   write_pickle.WriteBool(is_valid);
   write_pickle.WriteUInt32(dirty);
   write_pickle.WriteInt64(usage);
 
   if (!WriteBytes(usage_file_path,
                   static_cast<const char*>(write_pickle.data()),
                   write_pickle.size())) {
     Delete(usage_file_path);
     return false;
@@ skipping 76 matching lines @@
   return !task_runner_.get() || task_runner_->RunsTasksOnCurrentThread();
 }
 
 bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) {
   DCHECK(CalledOnValidThread());
   DCHECK_LE(cache_files_.size(), kMaxHandleCacheSize);
   return ContainsKey(cache_files_, file_path);
 }
 
 }  // namespace storage