Sign CertificateVerify messages on a background thread.

net/ssl/threaded_ssl_private_key.cc

+// Copyright 2015 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/ssl/threaded_ssl_private_key.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/task_runner.h"
+#include "base/thread_task_runner_handle.h"
+
+namespace net {
+
+namespace {
+
+void DoSign(const scoped_refptr<ThreadedSSLPrivateKey::Core>& core,
+            SSLPrivateKey::Hash hash,
+            const std::string& input,
+            const SSLPrivateKey::SignCallback& callback,
+            const scoped_refptr<base::TaskRunner>& task_runner) {
+  std::vector<uint8_t> signature;
+  Error error = core->SignDigest(hash, input, &signature);
+  task_runner->PostTask(FROM_HERE, base::Bind(callback, error, signature));
+}
+
+}  // namespace
+
+ThreadedSSLPrivateKey::ThreadedSSLPrivateKey(
+    const scoped_refptr<Core>& core,
+    const scoped_refptr<base::TaskRunner>& task_runner)
+    : core_(core), task_runner_(task_runner), weak_factory_(this) {
+}
+
+ThreadedSSLPrivateKey::~ThreadedSSLPrivateKey() {
+}
+
+SSLPrivateKey::Type ThreadedSSLPrivateKey::GetType() {
+  return core_->GetType();
+}
+
+bool ThreadedSSLPrivateKey::SupportsHash(SSLPrivateKey::Hash hash) {
+  return core_->SupportsHash(hash);
+}
+
+size_t ThreadedSSLPrivateKey::GetMaxSignatureLength() {
+  return core_->GetMaxSignatureLength();
+}
+
+void ThreadedSSLPrivateKey::SignDigest(
+    SSLPrivateKey::Hash hash,
+    const base::StringPiece& input,
+    const SSLPrivateKey::SignCallback& callback) {
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&DoSign, core_, hash, input.as_string(),
+                            base::Bind(&ThreadedSSLPrivateKey::DoCallback,
+                                       weak_factory_.GetWeakPtr(), callback),
+                            base::ThreadTaskRunnerHandle::Get()));

[Ryan Sleevi, 2015/06/12 23:37:20]

An alternative way to do this

namespace {

void DoCallback(const SSLPrivateKey::SignCallback& callback,
std::vector<uint8_t>* signature, Error result) {
  callback.Run(error, *signature);
};

}  // namespace

std::vector<uint8_t>* signature = new std::vector<uint8_t>;
task_runner_->PostTaskAndReplyWithResult(
   FROM_HERE,
   base::Bind(Core::SignDigest, core_, hash, input.as_string(), signature),
   base::Bind(DoCallback, callback, base::Owned(signature)));


The benefit to the above approach is it eliminates the need to have DoCallback &
DoSign - you can reduce that to one (if we had bound placeholders, you could
reorder the args via bind)

[davidben, 2015/06/15 21:28:25]

I don't believe it quite avoids the need for DoCallback; the callback should not
run if you destroy SSLPrivateKey. It somewhat avoids DoSign, though the
Core/Delegate split brings it back somewhat. The base::Unretained + base::Owned
pair kind of scares me somewhat, but okay.

Anyway, done.

+}
+
+void ThreadedSSLPrivateKey::DoCallback(
+    const SSLPrivateKey::SignCallback& callback,
+    Error error,
+    const std::vector<uint8_t>& signature) {
+  callback.Run(error, signature);
+}
+
+}  // namespace net