Change most uses of Pickle to base::Pickle

net/disk_cache/simple/simple_index_file.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 "net/disk_cache/simple/simple_index_file.h"
 
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 15 matching lines @@
 using base::File;
 
 namespace disk_cache {
 namespace {
 
 const int kEntryFilesHashLength = 16;
 const int kEntryFilesSuffixLength = 2;
 
 const uint64 kMaxEntiresInIndex = 100000000;
 
-uint32 CalculatePickleCRC(const Pickle& pickle) {
+uint32 CalculatePickleCRC(const base::Pickle& pickle) {
   return crc32(crc32(0, Z_NULL, 0),
                reinterpret_cast<const Bytef*>(pickle.payload()),
                pickle.payload_size());
 }
 
 // Used in histograms. Please only add new values at the end.
 enum IndexFileState {
   INDEX_STATE_CORRUPT = 0,
   INDEX_STATE_STALE = 1,
   INDEX_STATE_FRESH = 2,
@@ skipping 14 matching lines @@
   INITIALIZE_METHOD_MAX = 3,
 };
 
 void UmaRecordIndexInitMethod(IndexInitMethod method,
                               net::CacheType cache_type) {
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "IndexInitializeMethod", cache_type,
                    method, INITIALIZE_METHOD_MAX);
 }
 
-bool WritePickleFile(Pickle* pickle, const base::FilePath& file_name) {
+bool WritePickleFile(base::Pickle* pickle, const base::FilePath& file_name) {
   File file(
       file_name,
       File::FLAG_CREATE | File::FLAG_WRITE | File::FLAG_SHARE_DELETE);
   if (!file.IsValid())
     return false;
 
   int bytes_written =
       file.Write(0, static_cast<const char*>(pickle->data()), pickle->size());
   if (bytes_written != implicit_cast<int>(pickle->size())) {
     simple_util::SimpleCacheDeleteFile(file_name);
@@ skipping 77 matching lines @@
       number_of_entries_(0),
       cache_size_(0) {}
 
 SimpleIndexFile::IndexMetadata::IndexMetadata(
     uint64 number_of_entries, uint64 cache_size)
     : magic_number_(kSimpleIndexMagicNumber),
       version_(kSimpleVersion),
       number_of_entries_(number_of_entries),
       cache_size_(cache_size) {}
 
-void SimpleIndexFile::IndexMetadata::Serialize(Pickle* pickle) const {
+void SimpleIndexFile::IndexMetadata::Serialize(base::Pickle* pickle) const {
   DCHECK(pickle);
   pickle->WriteUInt64(magic_number_);
   pickle->WriteUInt32(version_);
   pickle->WriteUInt64(number_of_entries_);
   pickle->WriteUInt64(cache_size_);
 }
 
 // static
 bool SimpleIndexFile::SerializeFinalData(base::Time cache_modified,
-                                         Pickle* pickle) {
+                                         base::Pickle* pickle) {
   if (!pickle->WriteInt64(cache_modified.ToInternalValue()))
     return false;
   SimpleIndexFile::PickleHeader* header_p = pickle->headerT<PickleHeader>();
   header_p->crc = CalculatePickleCRC(*pickle);
   return true;
 }
 
-bool SimpleIndexFile::IndexMetadata::Deserialize(PickleIterator* it) {
+bool SimpleIndexFile::IndexMetadata::Deserialize(base::PickleIterator* it) {
   DCHECK(it);
   return it->ReadUInt64(&magic_number_) &&
       it->ReadUInt32(&version_) &&
       it->ReadUInt64(&number_of_entries_)&&
       it->ReadUInt64(&cache_size_);
 }
 
 void SimpleIndexFile::SyncWriteToDisk(net::CacheType cache_type,
                                       const base::FilePath& cache_directory,
                                       const base::FilePath& index_filename,
                                       const base::FilePath& temp_index_filename,
-                                      scoped_ptr<Pickle> pickle,
+                                      scoped_ptr<base::Pickle> pickle,
                                       const base::TimeTicks& start_time,
                                       bool app_on_background) {
   DCHECK_EQ(index_filename.DirName().value(),
             temp_index_filename.DirName().value());
   base::FilePath index_file_directory = temp_index_filename.DirName();
   if (!base::DirectoryExists(index_file_directory) &&
       !base::CreateDirectory(index_file_directory)) {
     LOG(ERROR) << "Could not create a directory to hold the index file";
     return;
   }
@@ skipping 64 matching lines @@
                                   index_file_, out_result);
   worker_pool_->PostTaskAndReply(FROM_HERE, task, callback);
 }
 
 void SimpleIndexFile::WriteToDisk(const SimpleIndex::EntrySet& entry_set,
                                   uint64 cache_size,
                                   const base::TimeTicks& start,
                                   bool app_on_background,
                                   const base::Closure& callback) {
   IndexMetadata index_metadata(entry_set.size(), cache_size);
-  scoped_ptr<Pickle> pickle = Serialize(index_metadata, entry_set);
+  scoped_ptr<base::Pickle> pickle = Serialize(index_metadata, entry_set);
   base::Closure task =
       base::Bind(&SimpleIndexFile::SyncWriteToDisk,
                  cache_type_, cache_directory_, index_file_, temp_index_file_,
                  base::Passed(&pickle), start, app_on_background);
   if (callback.is_null())
     cache_thread_->PostTask(FROM_HERE, task);
   else
     cache_thread_->PostTaskAndReply(FROM_HERE, task, callback);
 }
 
@@ skipping 67 matching lines @@
       reinterpret_cast<const char*>(index_file_map.data()),
       index_file_map.length(),
       out_last_cache_seen_by_index,
       out_result);
 
   if (!out_result->did_load)
     simple_util::SimpleCacheDeleteFile(index_filename);
 }
 
 // static
-scoped_ptr<Pickle> SimpleIndexFile::Serialize(
+scoped_ptr<base::Pickle> SimpleIndexFile::Serialize(
     const SimpleIndexFile::IndexMetadata& index_metadata,
     const SimpleIndex::EntrySet& entries) {
-  scoped_ptr<Pickle> pickle(new Pickle(sizeof(SimpleIndexFile::PickleHeader)));
+  scoped_ptr<base::Pickle> pickle(
+      new base::Pickle(sizeof(SimpleIndexFile::PickleHeader)));
 
   index_metadata.Serialize(pickle.get());
   for (SimpleIndex::EntrySet::const_iterator it = entries.begin();
        it != entries.end(); ++it) {
     pickle->WriteUInt64(it->first);
     it->second.Serialize(pickle.get());
   }
   return pickle.Pass();
 }
 
 // static
 void SimpleIndexFile::Deserialize(const char* data, int data_len,
                                   base::Time* out_cache_last_modified,
                                   SimpleIndexLoadResult* out_result) {
   DCHECK(data);
 
   out_result->Reset();
   SimpleIndex::EntrySet* entries = &out_result->entries;
 
-  Pickle pickle(data, data_len);
+  base::Pickle pickle(data, data_len);
   if (!pickle.data()) {
     LOG(WARNING) << "Corrupt Simple Index File.";
     return;
   }
 
-  PickleIterator pickle_it(pickle);
+  base::PickleIterator pickle_it(pickle);
   SimpleIndexFile::PickleHeader* header_p =
       pickle.headerT<SimpleIndexFile::PickleHeader>();
   const uint32 crc_read = header_p->crc;
   const uint32 crc_calculated = CalculatePickleCRC(pickle);
 
   if (crc_read != crc_calculated) {
     LOG(WARNING) << "Invalid CRC in Simple Index file.";
     return;
   }
 
@@ skipping 61 matching lines @@
 bool SimpleIndexFile::LegacyIsIndexFileStale(
     base::Time cache_last_modified,
     const base::FilePath& index_file_path) {
   base::Time index_mtime;
   if (!simple_util::GetMTime(index_file_path, &index_mtime))
     return true;
   return index_mtime < cache_last_modified;
 }
 
 }  // namespace disk_cache