Refactor WebRTC certificate generation to use WebPassOwnPtr.

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"
 #include "content/renderer/media/peer_connection_identity_store.h"
 #include "content/renderer/media/rtc_certificate.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/webrtc/base/rtccertificate.h"
 #include "third_party/webrtc/base/scoped_ref_ptr.h"
 #include "url/gurl.h"
@@ skipping 31 matching lines @@
   }
   ~RTCCertificateIdentityObserver() override {}
 
   // Perform |store|->RequestIdentity with this identity observer and ensure
   // that this identity observer is not deleted until the request has completed
   // by holding on to a reference to itself for the duration of the request.
   void RequestIdentity(
       const blink::WebRTCKeyParams& key_params,
       const GURL& url,
       const GURL& first_party_for_cookies,
-      blink::WebCallbacks<blink::WebRTCCertificate*, void>* observer) {
+      blink::WebPassOwnPtr<blink::WebRTCCertificateCallback> observer) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(!observer_) << "Already have a RequestIdentity in progress.";
-    DCHECK(observer);
     key_params_ = key_params;
     observer_ = observer;
+    DCHECK(observer_);
     // Identity request must be performed on the WebRTC signaling thread.
     signaling_thread_->PostTask(FROM_HERE, base::Bind(
         &RTCCertificateIdentityObserver::RequestIdentityOnWebRtcSignalingThread,
         this, url, first_party_for_cookies));
   }
 
  private:
   void RequestIdentityOnWebRtcSignalingThread(
       GURL url,
       GURL first_party_for_cookies) {
@@ skipping 34 matching lines @@
         rtc::RTCCertificate::Create(std::move(identity));
     main_thread_->PostTask(FROM_HERE, base::Bind(
         &RTCCertificateIdentityObserver::DoCallbackOnMainThread,
         this, new RTCCertificate(key_params_, certificate)));
   }
 
   void DoCallbackOnMainThread(blink::WebRTCCertificate* certificate) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     DCHECK(observer_);
     if (certificate)
-      observer_->onSuccess(certificate);
+      observer_->onSuccess(blink::adoptWebPtr(certificate));
     else
       observer_->onError();
+    observer_.reset();
   }
 
   // The main thread is the renderer thread.
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
   // The signaling thread is a WebRTC thread used to invoke
   // PeerConnectionIdentityStore::RequestIdentity on, as is required.
   const scoped_refptr<base::SingleThreadTaskRunner> signaling_thread_;
   blink::WebRTCKeyParams key_params_;
-  blink::WebCallbacks<blink::WebRTCCertificate*, void>* observer_;
+  scoped_ptr<blink::WebRTCCertificateCallback> observer_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCCertificateIdentityObserver);
 };
 
 }  // namespace
 
 void RTCCertificateGenerator::generateCertificate(
     const blink::WebRTCKeyParams& key_params,
     const blink::WebURL& url,
     const blink::WebURL& first_party_for_cookies,
-    blink::WebCallbacks<blink::WebRTCCertificate*, void>* observer) {
+    blink::WebPassOwnPtr<blink::WebRTCCertificateCallback> observer) {
   DCHECK(isSupportedKeyParams(key_params));
 
 #if defined(ENABLE_WEBRTC)
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread =
       base::ThreadTaskRunnerHandle::Get();
 
   PeerConnectionDependencyFactory* pc_dependency_factory =
       RenderThreadImpl::current()->GetPeerConnectionDependencyFactory();
   pc_dependency_factory->EnsureInitialized();
   const scoped_refptr<base::SingleThreadTaskRunner> signaling_thread =
       pc_dependency_factory->GetWebRtcSignalingThread();
 
   rtc::scoped_refptr<RTCCertificateIdentityObserver> identity_observer(
       new rtc::RefCountedObject<RTCCertificateIdentityObserver>(
           main_thread, signaling_thread));
   // |identity_observer| lives until request has completed.
   identity_observer->RequestIdentity(
       key_params, url, first_party_for_cookies, observer);
 #else
   observer->onError();
 #endif
 }
 
 bool RTCCertificateGenerator::isSupportedKeyParams(
     const blink::WebRTCKeyParams& key_params) {
   return WebRTCKeyParamsToKeyParams(key_params).IsValid();
 }
 
 }  // namespace content