SignedCertificateTimestamp storing & serialization code.

net/cert/signed_certificate_timestamp.cc

 // Copyright 2013 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/signed_certificate_timestamp.h"
 
+#include "base/pickle.h"
+
 namespace net {
 
 namespace ct {
 
 bool SignedCertificateTimestamp::LessThan::operator()(
     const scoped_refptr<SignedCertificateTimestamp>& lhs,
     const scoped_refptr<SignedCertificateTimestamp>& rhs) const {
   if (lhs.get() == rhs.get())
     return false;
   if (lhs->signature.signature_data != rhs->signature.signature_data)
     return lhs->signature.signature_data < rhs->signature.signature_data;
   if (lhs->log_id != rhs->log_id)
     return lhs->log_id < rhs->log_id;
   if (lhs->timestamp != rhs->timestamp)
     return lhs->timestamp < rhs->timestamp;
   if (lhs->extensions != rhs->extensions)
     return lhs->extensions < rhs->extensions;
   return lhs->version < rhs->version;
 }
 
 SignedCertificateTimestamp::SignedCertificateTimestamp() {}
 
 SignedCertificateTimestamp::~SignedCertificateTimestamp() {}
 
+void SignedCertificateTimestamp::Persist(Pickle* pickle) {
+  CHECK(pickle->WriteInt(version));
+  CHECK(pickle->WriteString(log_id));
+  CHECK(pickle->WriteInt64(timestamp.ToInternalValue()));
+  CHECK(pickle->WriteString(extensions));
+  CHECK(pickle->WriteInt(signature.hash_algorithm));
+  CHECK(pickle->WriteInt(signature.signature_algorithm));
+  CHECK(pickle->WriteString(signature.signature_data));
+}
+
+// static
+SignedCertificateTimestamp*
+SignedCertificateTimestamp::CreateFromPickle(PickleIterator* iter) {
+  int version;
+  std::string log_id;
+  int64 timestamp;
+  std::string extensions;
+  int hash_algorithm;
+  int sig_algorithm;
+  std::string sig_data;

[wtc, 2013/11/27 16:32:41]

Nit: you can store the new SignedCertificateTimestamp in a scoped_ptr. Then,
pass its std::string members to iter->ReadString(). This will avoid string
copying.

[wtc, 2013/11/27 17:29:18]

I just realized that SignedCertificateTimestamp is a referenced-counted type, so
we can't store it in a scoped_ptr. My suggestion needs more work.

Maybe this function needs to return a scoped_refptr<SignedCertificateTimestamp>.
Then we can store the new SignedCertificateTimestamp in a scoped_refptr.

[alcutter, 2013/11/27 18:05:55]

That occurred to me too, but I thought the split of setting some things directly
and other via locals might be a bit confusing.  I've done it anyway, but added a
small comment.

[alcutter, 2013/11/27 18:05:55]

Ah, I'd assumed you meant a scoped_refptr in the original comment anyway.
This was loosely modelled on the x509_certificate CreateFromPickle which returns
a raw ptr, but I guess a scoped_refptr works too possibly at the cost of an
extra AddRef()/Release().

I've changed to return a scoped_refptr for now, but I'm happy to do whatever you
recommend.

[wtc, 2013/11/28 01:28:02]

The new convention in Chromium seems to recommend we always use a scoped_refptr
with a reference-counted type. X509Certificate::CreateFromPickle was written
before the new convention was formed, which is why it returns a raw pointer.

Personally, I think the new convention can result in verbose code and extra
AddRef()/Release() calls, which may incur atomic instruction overhead, but I
understand its benefits.

[alcutter, 2013/11/28 12:08:19]

Ack.

+  if (!(iter->ReadInt(&version) &&
+        iter->ReadString(&log_id) &&
+        iter->ReadInt64(&timestamp) &&
+        iter->ReadString(&extensions) &&
+        iter->ReadInt(&hash_algorithm) &&
+        iter->ReadInt(&sig_algorithm) &&
+        iter->ReadString(&sig_data))) {
+    return NULL;
+  }
+  SignedCertificateTimestamp* sct(new SignedCertificateTimestamp());
+  sct->version = static_cast<Version>(version);
+  sct->log_id = log_id;
+  sct->timestamp = base::Time::FromInternalValue(timestamp);
+  sct->extensions = extensions;
+  sct->signature.hash_algorithm =
+      static_cast<DigitallySigned::HashAlgorithm>(hash_algorithm);
+  sct->signature.signature_algorithm =
+      static_cast<DigitallySigned::SignatureAlgorithm>(sig_algorithm);
+  sct->signature.signature_data = sig_data;
+  return sct;
+}
+
 LogEntry::LogEntry() {}
 
 LogEntry::~LogEntry() {}
 
 void LogEntry::Reset() {
   type = LogEntry::LOG_ENTRY_TYPE_X509;
   leaf_certificate.clear();
   tbs_certificate.clear();
 }
 
 DigitallySigned::DigitallySigned() {}
 
 DigitallySigned::~DigitallySigned() {}
 
 }  // namespace ct
 
 }  // namespace net