Move Pickle to base namespace.

net/cert/x509_certificate.h

 // 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.
 
 #ifndef NET_CERT_X509_CERTIFICATE_H_
 #define NET_CERT_X509_CERTIFICATE_H_
 
 #include <string.h>
 
 #include <string>
@@ skipping 15 matching lines @@
 #include <Security/SecBase.h>
 #elif defined(USE_OPENSSL_CERTS)
 // Forward declaration; real one in <x509.h>
 typedef struct x509_st X509;
 typedef struct x509_store_st X509_STORE;
 #elif defined(USE_NSS_CERTS)
 // Forward declaration; real one in <cert.h>
 struct CERTCertificateStr;
 #endif
 
+namespace base {
 class Pickle;
 class PickleIterator;
+}
 
 namespace net {
 
 class CRLSet;
 class CertVerifyResult;
 
 typedef std::vector<scoped_refptr<X509Certificate> > CertificateList;
 
 // X509Certificate represents a X.509 certificate, which is comprised a
 // particular identity or end-entity certificate, such as an SSL server
@@ skipping 124 matching lines @@
   // then this will return the nickname specified upon creation.
   std::string GetDefaultNickname(CertType type) const;
 #endif
 
   // Create an X509Certificate from the representation stored in the given
   // pickle.  The data for this object is found relative to the given
   // pickle_iter, which should be passed to the pickle's various Read* methods.
   // Returns NULL on failure.
   //
   // The returned pointer must be stored in a scoped_refptr<X509Certificate>.
-  static X509Certificate* CreateFromPickle(PickleIterator* pickle_iter,
+  static X509Certificate* CreateFromPickle(base::PickleIterator* pickle_iter,
                                            PickleType type);
 
   // Parses all of the certificates possible from |data|. |format| is a
   // bit-wise OR of Format, indicating the possible formats the
   // certificates may have been serialized as. If an error occurs, an empty
   // collection will be returned.
   static CertificateList CreateCertificateListFromBytes(const char* data,
                                                         int length,
                                                         int format);
 
   // Appends a representation of this object to the given pickle.
-  void Persist(Pickle* pickle);
+  void Persist(base::Pickle* pickle);
 
   // The serial number, DER encoded, possibly including a leading 00 byte.
   const std::string& serial_number() const { return serial_number_; }
 
   // The subject of the certificate.  For HTTPS server certificates, this
   // represents the web server.  The common name of the subject should match
   // the host name of the web server.
   const CertPrincipal& subject() const { return subject_; }
 
   // The issuer of the certificate.
@@ skipping 262 matching lines @@
                              const std::vector<std::string>& cert_san_ip_addrs,
                              bool* common_name_fallback_used);
 
   // Reads a single certificate from |pickle_iter| and returns a
   // platform-specific certificate handle. The format of the certificate
   // stored in |pickle_iter| is not guaranteed to be the same across different
   // underlying cryptographic libraries, nor acceptable to CreateFromBytes().
   // Returns an invalid handle, NULL, on failure.
   // NOTE: This should not be used for any new code. It is provided for
   // migration purposes and should eventually be removed.
-  static OSCertHandle ReadOSCertHandleFromPickle(PickleIterator* pickle_iter);
+  static OSCertHandle ReadOSCertHandleFromPickle(
+      base::PickleIterator* pickle_iter);
 
   // Writes a single certificate to |pickle| in DER form. Returns false on
   // failure.
-  static bool WriteOSCertHandleToPickle(OSCertHandle handle, Pickle* pickle);
+  static bool WriteOSCertHandleToPickle(OSCertHandle handle,
+                                        base::Pickle* pickle);
 
   // The subject of the certificate.
   CertPrincipal subject_;
 
   // The issuer of the certificate.
   CertPrincipal issuer_;
 
   // This certificate is not valid before |valid_start_|
   base::Time valid_start_;
 
@@ skipping 23 matching lines @@
   // based on the type of the certificate.
   std::string default_nickname_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(X509Certificate);
 };
 
 }  // namespace net
 
 #endif  // NET_CERT_X509_CERTIFICATE_H_