Change most uses of Pickle to base::Pickle

net/cert/x509_certificate.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 "net/cert/x509_certificate.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 294 matching lines @@
   OSCertHandle cert_handle = CreateOSCertHandleFromBytes(data, length);
   if (!cert_handle)
     return NULL;
 
   X509Certificate* cert = CreateFromHandle(cert_handle, OSCertHandles());
   FreeOSCertHandle(cert_handle);
   return cert;
 }
 
 // static
-X509Certificate* X509Certificate::CreateFromPickle(PickleIterator* pickle_iter,
-                                                   PickleType type) {
+X509Certificate* X509Certificate::CreateFromPickle(
+    base::PickleIterator* pickle_iter,
+    PickleType type) {
   if (type == PICKLETYPE_CERTIFICATE_CHAIN_V3) {
     int chain_length = 0;
     if (!pickle_iter->ReadLength(&chain_length))
       return NULL;
 
     std::vector<base::StringPiece> cert_chain;
     const char* data = NULL;
     int data_length = 0;
     for (int i = 0; i < chain_length; ++i) {
       if (!pickle_iter->ReadData(&data, &data_length))
@@ skipping 25 matching lines @@
     // x86-64 is little-endian, if that happens, the next 32 bits will be all
     // zeroes (the high bits) and the 32 bits we already read above are the
     // correct value (we assume there are never more than 2^32 - 1 intermediate
     // certificates in a chain; in practice, more than a dozen or so is
     // basically unheard of). Since it's invalid for a certificate to start with
     // 32 bits of zeroes, we check for that here and skip it if we find it. We
     // save a copy of the pickle iterator to restore in case we don't get 32
     // bits of zeroes. Now we always write 32 bits, so after a while, these old
     // cached pickles will all get replaced.
     // TODO(mdm): remove this compatibility code in April 2013 or so.
-    PickleIterator saved_iter = *pickle_iter;
+    base::PickleIterator saved_iter = *pickle_iter;
     uint32 zero_check = 0;
     if (!pickle_iter->ReadUInt32(&zero_check)) {
       // This may not be an error. If there are no intermediates, and we're
       // reading an old 32-bit pickle, and there's nothing else after this in
       // the pickle, we should report success. Note that it is technically
       // possible for us to skip over zeroes that should have occurred after
       // an empty certificate list; to avoid this going forward, only do this
       // backward-compatibility stuff for PICKLETYPE_CERTIFICATE_CHAIN_V1
       // which comes from the pickle version number in http_response_info.cc.
       if (num_intermediates) {
@@ skipping 93 matching lines @@
   for (OSCertHandles::iterator it = certificates.begin();
        it != certificates.end(); ++it) {
     X509Certificate* result = CreateFromHandle(*it, OSCertHandles());
     results.push_back(scoped_refptr<X509Certificate>(result));
     FreeOSCertHandle(*it);
   }
 
   return results;
 }
 
-void X509Certificate::Persist(Pickle* pickle) {
+void X509Certificate::Persist(base::Pickle* pickle) {
   DCHECK(cert_handle_);
   // This would be an absolutely insane number of intermediates.
   if (intermediate_ca_certs_.size() > static_cast<size_t>(INT_MAX) - 1) {
     NOTREACHED();
     return;
   }
   if (!pickle->WriteInt(
           static_cast<int>(intermediate_ca_certs_.size() + 1)) ||
       !WriteOSCertHandleToPickle(cert_handle_, pickle)) {
     NOTREACHED();
@@ skipping 269 matching lines @@
     RemoveFromCache(cert_handle_);
     FreeOSCertHandle(cert_handle_);
   }
   for (size_t i = 0; i < intermediate_ca_certs_.size(); ++i) {
     RemoveFromCache(intermediate_ca_certs_[i]);
     FreeOSCertHandle(intermediate_ca_certs_[i]);
   }
 }
 
 }  // namespace net