Change most uses of Pickle to base::Pickle

content/browser/appcache/appcache_response.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 "content/browser/appcache/appcache_response.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 
 namespace {
 
 // Disk cache entry data indices.
 enum { kResponseInfoIndex, kResponseContentIndex, kResponseMetadataIndex };
 
 // An IOBuffer that wraps a pickle's data. Ownership of the
 // pickle is transfered to the WrappedPickleIOBuffer object.
 class WrappedPickleIOBuffer : public net::WrappedIOBuffer {
  public:
-  explicit WrappedPickleIOBuffer(const Pickle* pickle) :
-      net::WrappedIOBuffer(reinterpret_cast<const char*>(pickle->data())),
-      pickle_(pickle) {
+  explicit WrappedPickleIOBuffer(const base::Pickle* pickle)
+      : net::WrappedIOBuffer(reinterpret_cast<const char*>(pickle->data())),
+        pickle_(pickle) {
     DCHECK(pickle->data());
   }
 
  private:
   ~WrappedPickleIOBuffer() override {}
 
-  scoped_ptr<const Pickle> pickle_;
+  scoped_ptr<const base::Pickle> pickle_;
 };
 
 }  // anon namespace
 
 
 // AppCacheResponseInfo ----------------------------------------------
 
 AppCacheResponseInfo::AppCacheResponseInfo(
     AppCacheStorage* storage, const GURL& manifest_url,
     int64 response_id,  net::HttpResponseInfo* http_info,
@@ skipping 195 matching lines @@
 }
 
 void AppCacheResponseReader::OnIOComplete(int result) {
   if (result >= 0) {
     if (reading_metadata_size_) {
       DCHECK(reading_metadata_size_ == result);
       DCHECK(info_buffer_->http_info->metadata);
       reading_metadata_size_ = 0;
     } else if (info_buffer_.get()) {
       // Deserialize the http info structure, ensuring we got headers.
-      Pickle pickle(buffer_->data(), result);
+      base::Pickle pickle(buffer_->data(), result);
       scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
       bool response_truncated = false;
       if (!info->InitFromPickle(pickle, &response_truncated) ||
           !info->headers.get()) {
         InvokeUserCompletionCallback(net::ERR_FAILED);
         return;
       }
       DCHECK(!response_truncated);
       info_buffer_->http_info.reset(info.release());
 
@@ skipping 61 matching lines @@
 }
 
 void AppCacheResponseWriter::ContinueWriteInfo() {
   if (!entry_) {
     ScheduleIOCompletionCallback(net::ERR_FAILED);
     return;
   }
 
   const bool kSkipTransientHeaders = true;
   const bool kTruncated = false;
-  Pickle* pickle = new Pickle;
+  base::Pickle* pickle = new base::Pickle;
   info_buffer_->http_info->Persist(pickle, kSkipTransientHeaders, kTruncated);
   write_amount_ = static_cast<int>(pickle->size());
   buffer_ = new WrappedPickleIOBuffer(pickle);  // takes ownership of pickle
   WriteRaw(kResponseInfoIndex, 0, buffer_.get(), write_amount_);
 }
 
 void AppCacheResponseWriter::WriteData(
     net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsWritePending());
@@ skipping 125 matching lines @@
   }
   WriteRaw(kResponseMetadataIndex, 0, buffer_.get(), write_amount_);
 }
 
 void AppCacheResponseMetadataWriter::OnIOComplete(int result) {
   DCHECK(result < 0 || write_amount_ == result);
   InvokeUserCompletionCallback(result);
 }
 
 }  // namespace content