Fix for spdy cancelling ServerBoundCertServiceRequest

net/base/server_bound_cert_service.cc

 // 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.
 
 #include "net/base/server_bound_cert_service.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 331 matching lines @@
     }
   }
 
   std::vector<ServerBoundCertServiceRequest*> requests_;
   SSLClientCertType type_;
 };
 
 // static
 const char ServerBoundCertService::kEPKIPassword[] = "";
 
+ServerBoundCertService::RequestHandle::RequestHandle()
+    : service_(NULL),
+      request_(NULL) {}
+
+ServerBoundCertService::RequestHandle::~RequestHandle() {
+  Cancel();
+}
+
+void ServerBoundCertService::RequestHandle::Cancel() {
+  if (request_) {
+    service_->CancelRequest(request_);
+    request_ = NULL;
+    callback_.Reset();
+  }
+}
+
+void ServerBoundCertService::RequestHandle::RequestStarted(
+    ServerBoundCertService* service,
+    ServerBoundCertServiceRequest* request,
+    const CompletionCallback& callback) {
+  DCHECK(request_ == NULL);
+  service_ = service;
+  request_ = request;
+  callback_ = callback;
+}
+
+void ServerBoundCertService::RequestHandle::OnRequestComplete(int result) {
+  request_ = NULL;
+  callback_.Run(result);
+  callback_.Reset();
+}
+
 ServerBoundCertService::ServerBoundCertService(
     ServerBoundCertStore* server_bound_cert_store,
     const scoped_refptr<base::TaskRunner>& task_runner)
     : server_bound_cert_store_(server_bound_cert_store),
       task_runner_(task_runner),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       requests_(0),
       cert_store_hits_(0),
       inflight_joins_(0) {
   base::Time start = base::Time::Now();
@@ skipping 22 matching lines @@
     std::string* private_key,
     std::string* cert,
     const CompletionCallback& callback,
     RequestHandle* out_req) {
   DVLOG(1) << __FUNCTION__ << " " << origin << " "
            << (requested_types.empty() ? -1 : requested_types[0])
            << (requested_types.size() > 1 ? "..." : "");
   DCHECK(CalledOnValidThread());
   base::TimeTicks request_start = base::TimeTicks::Now();
 
-  *out_req = NULL;
-
   if (callback.is_null() || !private_key || !cert || origin.empty() ||
       requested_types.empty()) {
     RecordGetDomainBoundCertResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
 
   std::string domain = GetDomainForHost(GURL(origin).host());
   if (domain.empty()) {
     RecordGetDomainBoundCertResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
@@ skipping 78 matching lines @@
       // TODO(rkn): Log to the NetLog.
       LOG(ERROR) << "ServerBoundCertServiceWorker couldn't be started.";
       RecordGetDomainBoundCertResult(WORKER_FAILURE);
       return ERR_INSUFFICIENT_RESOURCES;  // Just a guess.
     }
     job = new ServerBoundCertServiceJob(preferred_type);
     inflight_[domain] = job;
   }
 
   ServerBoundCertServiceRequest* request = new ServerBoundCertServiceRequest(
-      request_start, callback, type, private_key, cert);
+      request_start,
+      base::Bind(&RequestHandle::OnRequestComplete, base::Unretained(out_req)),
+      type, private_key, cert);
   job->AddRequest(request);
-  *out_req = request;
+  out_req->RequestStarted(this, request, callback);
   return ERR_IO_PENDING;
 }
 
 ServerBoundCertStore* ServerBoundCertService::GetCertStore() {
   return server_bound_cert_store_.get();
 }
 
-void ServerBoundCertService::CancelRequest(RequestHandle req) {
+void ServerBoundCertService::CancelRequest(ServerBoundCertServiceRequest* req) {
   DCHECK(CalledOnValidThread());
-  ServerBoundCertServiceRequest* request =
-      reinterpret_cast<ServerBoundCertServiceRequest*>(req);
-  request->Cancel();
+  req->Cancel();
 }
 
 // HandleResult is called by ServerBoundCertServiceWorker on the origin message
 // loop. It deletes ServerBoundCertServiceJob.
 void ServerBoundCertService::HandleResult(
     const std::string& server_identifier,
     int error,
     scoped_ptr<ServerBoundCertStore::ServerBoundCert> cert) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 19 matching lines @@
   else
     job->HandleResult(error, CLIENT_CERT_INVALID_TYPE, "", "");
   delete job;
 }
 
 int ServerBoundCertService::cert_count() {
   return server_bound_cert_store_->GetCertCount();
 }
 
 }  // namespace net