Added serialization to SecureHash.

crypto/secure_hash.h

 // Copyright (c) 2011 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 CRYPTO_SECURE_HASH_H_
 #define CRYPTO_SECURE_HASH_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "crypto/crypto_export.h"
 
+class Pickle;
+
 namespace crypto {
 
 // A wrapper to calculate secure hashes incrementally, allowing to
 // be used when the full input is not known in advance.
 class CRYPTO_EXPORT SecureHash {
  public:
   enum Algorithm {
     SHA256,
   };
   virtual ~SecureHash() {}
 
   static SecureHash* Create(Algorithm type);
 
   virtual void Update(const void* input, size_t len) = 0;
   virtual void Finish(void* output, size_t len) = 0;
 
+  // Serialize the context, so it can be restored at a later time.
+  // |pickle| will contain the serialized data.
+  // Returns whether or not |pickle| was filled.
+  virtual bool Serialize(Pickle* pickle) = 0;
+
+  // Restore the context that was saved earlier.

[Randy Smith (Not in Mondays), 2011/11/18 19:01:47]

Maybe worthwhile indicating that it will wipe out any in-progress context?

I find myself wondering if this could be replaced by a constructor taking a
Pickle*, but my guess is that that goes against the way Pickle is used in most
places, so it's probably not a good idea.  A related thing that might or might
not be a good idea would be to make a version of the Create() method that takes
a Pickle and automatically creates the type of SecureHash that it represents;
something to chat with the crypto owners about.

[ahendrickson, 2011/11/18 19:47:00]

I don't believe that we can currently have both NSS and OpenSSL hashes in the
same build, although it looks like we're on the way to supporting both.  The
Create() code takes the same parameter in both implementations, it's just that
only one of them is built at a time.  See crbug 62803.

There is a flag in build/common.gyp called use_openssl.

+  // |pickle| holds the saved data.
+  // Returns success or failure.
+  virtual bool Deserialize(Pickle* pickle) = 0;
+
  protected:
   SecureHash() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SecureHash);
 };
 
 }  // namespace crypto
 
 #endif  // CRYPTO_SECURE_HASH_H_