Change most uses of Pickle to base::Pickle

storage/browser/fileapi/sandbox_directory_database.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/sandbox_directory_database.h"
 
 #include <math.h>
 #include <algorithm>
 #include <set>
 #include <stack>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "storage/browser/fileapi/file_system_usage_cache.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace {
 
 bool PickleFromFileInfo(const storage::SandboxDirectoryDatabase::FileInfo& info,
-                        Pickle* pickle) {
+                        base::Pickle* pickle) {
   DCHECK(pickle);
   std::string data_path;
   // Round off here to match the behavior of the filesystem on real files.
   base::Time time =
       base::Time::FromDoubleT(floor(info.modification_time.ToDoubleT()));
   std::string name;
 
   data_path = storage::FilePathToString(info.data_path);
   name = storage::FilePathToString(base::FilePath(info.name));
 
   if (pickle->WriteInt64(info.parent_id) &&
       pickle->WriteString(data_path) &&
       pickle->WriteString(name) &&
       pickle->WriteInt64(time.ToInternalValue()))
     return true;
 
   NOTREACHED();
   return false;
 }
 
-bool FileInfoFromPickle(const Pickle& pickle,
+bool FileInfoFromPickle(const base::Pickle& pickle,
                         storage::SandboxDirectoryDatabase::FileInfo* info) {
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   std::string data_path;
   std::string name;
   int64 internal_time;
 
   if (iter.ReadInt64(&info->parent_id) &&
       iter.ReadString(&data_path) &&
       iter.ReadString(&name) &&
       iter.ReadInt64(&internal_time)) {
     info->data_path = storage::StringToFilePath(data_path);
     info->name = storage::StringToFilePath(name).value();
     info->modification_time = base::Time::FromInternalValue(internal_time);
     return true;
   }
-  LOG(ERROR) << "Pickle could not be digested!";
+  LOG(ERROR) << "base::Pickle could not be digested!";
   return false;
 }
 
 const base::FilePath::CharType kDirectoryDatabaseName[] =
     FILE_PATH_LITERAL("Paths");
 const char kChildLookupPrefix[] = "CHILD_OF:";
 const char kChildLookupSeparator[] = ":";
 const char kLastFileIdKey[] = "LAST_FILE_ID";
 const char kLastIntegerKey[] = "LAST_INTEGER";
 const int64 kMinimumReportIntervalHours = 1;
@@ skipping 141 matching lines @@
       // key: "LAST_INTEGER"
       // value: "<last_integer>"
       if (last_integer_ >= 0 ||
           !base::StringToInt64(itr->value().ToString(), &last_integer_))
         return false;
     } else {
       // key: "<entry_id>"
       // value: "<pickled FileInfo>"
       FileInfo file_info;
       if (!FileInfoFromPickle(
-              Pickle(itr->value().data(), itr->value().size()), &file_info))
+              base::Pickle(itr->value().data(), itr->value().size()),
+              &file_info))
         return false;
 
       FileId file_id = -1;
       if (!base::StringToInt64(key, &file_id) || file_id < 0)
         return false;
 
       if (max_file_id < file_id)
         max_file_id = file_id;
       if (!file_ids.insert(file_id).second)
         return false;
@@ skipping 253 matching lines @@
 bool SandboxDirectoryDatabase::GetFileInfo(FileId file_id, FileInfo* info) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   DCHECK(info);
   std::string file_key = GetFileLookupKey(file_id);
   std::string file_data_string;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), file_key, &file_data_string);
   if (status.ok()) {
     bool success = FileInfoFromPickle(
-        Pickle(file_data_string.data(), file_data_string.length()), info);
+        base::Pickle(file_data_string.data(), file_data_string.length()), info);
     if (!success)
       return false;
     if (!VerifyDataPath(info->data_path)) {
       LOG(ERROR) << "Resolved data path is invalid: "
                  << info->data_path.value();
       return false;
     }
     return true;
   }
   // Special-case the root, for databases that haven't been initialized yet.
@@ skipping 102 matching lines @@
   }
   return true;
 }
 
 bool SandboxDirectoryDatabase::UpdateModificationTime(
     FileId file_id, const base::Time& modification_time) {
   FileInfo info;
   if (!GetFileInfo(file_id, &info))
     return false;
   info.modification_time = modification_time;
-  Pickle pickle;
+  base::Pickle pickle;
   if (!PickleFromFileInfo(info, &pickle))
     return false;
   leveldb::Status status = db_->Put(
       leveldb::WriteOptions(),
       GetFileLookupKey(file_id),
       leveldb::Slice(reinterpret_cast<const char *>(pickle.data()),
                      pickle.size()));
   if (!status.ok()) {
     HandleError(FROM_HERE, status);
     return false;
@@ skipping 11 matching lines @@
   if (!GetFileInfo(dest_file_id, &dest_file_info))
     return false;
   if (src_file_info.is_directory() || dest_file_info.is_directory())
     return false;
   leveldb::WriteBatch batch;
   // This is the only field that really gets moved over; if you add fields to
   // FileInfo, e.g. ctime, they might need to be copied here.
   dest_file_info.data_path = src_file_info.data_path;
   if (!RemoveFileInfoHelper(src_file_id, &batch))
     return false;
-  Pickle pickle;
+  base::Pickle pickle;
   if (!PickleFromFileInfo(dest_file_info, &pickle))
     return false;
   batch.Put(
       GetFileLookupKey(dest_file_id),
       leveldb::Slice(reinterpret_cast<const char *>(pickle.data()),
                      pickle.size()));
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok()) {
     HandleError(FROM_HERE, status);
     return false;
@@ skipping 225 matching lines @@
   }
   std::string id_string = GetFileLookupKey(file_id);
   if (!file_id) {
     // The root directory doesn't need to be looked up by path from its parent.
     DCHECK(!info.parent_id);
     DCHECK(info.data_path.empty());
   } else {
     std::string child_key = GetChildLookupKey(info.parent_id, info.name);
     batch->Put(child_key, id_string);
   }
-  Pickle pickle;
+  base::Pickle pickle;
   if (!PickleFromFileInfo(info, &pickle))
     return false;
   batch->Put(
       id_string,
       leveldb::Slice(reinterpret_cast<const char *>(pickle.data()),
                      pickle.size()));
   return true;
 }
 
 // This does very few safety checks!
@@ skipping 20 matching lines @@
 
 void SandboxDirectoryDatabase::HandleError(
     const tracked_objects::Location& from_here,
     const leveldb::Status& status) {
   LOG(ERROR) << "SandboxDirectoryDatabase failed at: "
              << from_here.ToString() << " with error: " << status.ToString();
   db_.reset();
 }
 
 }  // namespace storage