Do not delete blink::WebRTCCertificateCallback on non-main thread

content/renderer/media/rtc_certificate_generator.cc

 // Copyright (c) 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 "content/renderer/media/rtc_certificate_generator.h"
 
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 25 matching lines @@
       return rtc::KeyParams();
   }
 }
 
 // A certificate generation request spawned by
 // |RTCCertificateGenerator::generateCertificateWithOptionalExpiration|. This
 // is handled by a separate class so that reference counting can keep the
 // request alive independently of the |RTCCertificateGenerator| that spawned it.
 class RTCCertificateGeneratorRequest
     : public base::RefCountedThreadSafe<RTCCertificateGeneratorRequest> {
+ private:
+  using CertificateCallbackPtr = std::unique_ptr<
+     blink::WebRTCCertificateCallback,
+     base::OnTaskRunnerDeleter>;
  public:
   RTCCertificateGeneratorRequest(
       const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& worker_thread)
       : main_thread_(main_thread),
         worker_thread_(worker_thread) {
     DCHECK(main_thread_);
     DCHECK(worker_thread_);
   }
 
   void GenerateCertificateAsync(
       const blink::WebRTCKeyParams& key_params,
       const rtc::Optional<uint64_t>& expires_ms,
       std::unique_ptr<blink::WebRTCCertificateCallback> observer) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(observer);
+
+    auto transition = base::WrapUnique(

[dcheng, 2016/07/22 06:12:04]

Since this is typedefed, maybe we can just write
CertificateCallbackPtr(observer.release(), base::OnTaskRunnerDeleter(...))

This feels like a pretty niche use case.

[tzik, 2016/07/22 07:27:21]

Done.

+        observer.release(),
+        base::OnTaskRunnerDeleter(base::ThreadTaskRunnerHandle::Get()));
     worker_thread_->PostTask(FROM_HERE, base::Bind(
         &RTCCertificateGeneratorRequest::GenerateCertificateOnWorkerThread,
         this,
         key_params,
         expires_ms,
-        base::Passed(std::move(observer))));
+        base::Passed(std::move(transition))));
   }
 
  private:
   friend class base::RefCountedThreadSafe<RTCCertificateGeneratorRequest>;
   ~RTCCertificateGeneratorRequest() {}
 
   void GenerateCertificateOnWorkerThread(
       const blink::WebRTCKeyParams key_params,
       const rtc::Optional<uint64_t> expires_ms,
-      std::unique_ptr<blink::WebRTCCertificateCallback> observer) {
+      CertificateCallbackPtr observer) {
     DCHECK(worker_thread_->BelongsToCurrentThread());
 
     rtc::scoped_refptr<rtc::RTCCertificate> certificate =
         rtc::RTCCertificateGenerator::GenerateCertificate(
             WebRTCKeyParamsToKeyParams(key_params), expires_ms);
 
     main_thread_->PostTask(FROM_HERE, base::Bind(
         &RTCCertificateGeneratorRequest::DoCallbackOnMainThread,
         this,
         base::Passed(std::move(observer)),
         base::Passed(base::WrapUnique(new RTCCertificate(certificate)))));
   }
 
   void DoCallbackOnMainThread(
-      std::unique_ptr<blink::WebRTCCertificateCallback> observer,
+      CertificateCallbackPtr observer,
       std::unique_ptr<blink::WebRTCCertificate> certificate) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(observer);
     if (certificate)
       observer->onSuccess(std::move(certificate));
     else
       observer->onError();
   }
 
   // The main thread is the renderer thread.
@@ skipping 52 matching lines @@
     blink::WebString pem_certificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate =
       rtc::RTCCertificate::FromPEM(
           rtc::RTCCertificatePEM(pem_private_key.utf8(),
               pem_certificate.utf8()));
   return std::unique_ptr<blink::WebRTCCertificate>(
       new RTCCertificate(certificate));
 }
 
 }  // namespace content