Support EC certs in OriginBoundCertService and OriginBoundCertStore.

net/base/default_origin_bound_cert_store.cc

 // 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.
 
 #include "net/base/default_origin_bound_cert_store.h"
 
 #include "base/message_loop.h"
 
 namespace net {
 
 // static
 const size_t DefaultOriginBoundCertStore::kMaxCerts = 3300;
 
 DefaultOriginBoundCertStore::DefaultOriginBoundCertStore(
     PersistentStore* store)
     : initialized_(false),
       store_(store) {}
 
 void DefaultOriginBoundCertStore::FlushStore(Task* completion_task) {
   base::AutoLock autolock(lock_);
 
   if (initialized_ && store_)
     store_->Flush(completion_task);
   else if (completion_task)
     MessageLoop::current()->PostTask(FROM_HERE, completion_task);
 }
 
 bool DefaultOriginBoundCertStore::GetOriginBoundCert(
     const std::string& origin,
+    OriginBoundCertType* type,
     std::string* private_key_result,
     std::string* cert_result) {
   base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   OriginBoundCertMap::iterator it = origin_bound_certs_.find(origin);
 
   if (it == origin_bound_certs_.end())
     return false;
 
   OriginBoundCert* cert = it->second;
+  *type = cert->type();
   *private_key_result = cert->private_key();
   *cert_result = cert->cert();
 
   return true;
 }
 
 void DefaultOriginBoundCertStore::SetOriginBoundCert(
     const std::string& origin,
+    OriginBoundCertType type,
     const std::string& private_key,
     const std::string& cert) {
   base::AutoLock autolock(lock_);
   InitIfNecessary();
 
   InternalDeleteOriginBoundCert(origin);
-  InternalInsertOriginBoundCert(origin,
-                                new OriginBoundCert(origin, private_key, cert));
+  InternalInsertOriginBoundCert(
+      origin, new OriginBoundCert(origin, type, private_key, cert));
 }
 
 void DefaultOriginBoundCertStore::DeleteOriginBoundCert(
     const std::string& origin) {
   base::AutoLock autolock(lock_);
   InitIfNecessary();
   InternalDeleteOriginBoundCert(origin);
 }
 
 void DefaultOriginBoundCertStore::DeleteAll() {
@@ skipping 10 matching lines @@
 }
 
 void DefaultOriginBoundCertStore::GetAllOriginBoundCerts(
     std::vector<OriginBoundCertInfo>* origin_bound_certs) {
   base::AutoLock autolock(lock_);
   InitIfNecessary();
   for (OriginBoundCertMap::iterator it = origin_bound_certs_.begin();
        it != origin_bound_certs_.end(); ++it) {
     OriginBoundCertInfo cert_info = {
       it->second->origin(),
+      it->second->type(),
       it->second->private_key(),
       it->second->cert()
     };
     // TODO(rkn): Make changes so we can simply write
     // origin_bound_certs->push_back(*it->second). This is probably best done
     // by unnesting the OriginBoundCert class.
     origin_bound_certs->push_back(cert_info);
   }
 }
 
@@ skipping 58 matching lines @@
 
   if (store_)
     store_->AddOriginBoundCert(*cert);
   origin_bound_certs_[origin] = cert;
 }
 
 DefaultOriginBoundCertStore::OriginBoundCert::OriginBoundCert() {}
 
 DefaultOriginBoundCertStore::OriginBoundCert::OriginBoundCert(
     const std::string& origin,
+    OriginBoundCertType type,
     const std::string& private_key,
     const std::string& cert)
     : origin_(origin),
+      type_(type),
       private_key_(private_key),
       cert_(cert) {}
 
 DefaultOriginBoundCertStore::PersistentStore::PersistentStore() {}
 
 }  // namespace net