Fix cyclic dependency between ProfilePolicyConnector and PrefService.

chrome/browser/chromeos/policy/policy_cert_verifier.cc

 // Copyright (c) 2013 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 "chrome/browser/chromeos/policy/policy_cert_verifier.h"
 
 #include "base/logging.h"
-#include "base/memory/ref_counted.h"
 #include "chrome/browser/browser_process.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/multi_threaded_cert_verifier.h"
 
 namespace policy {
 
-namespace {
-
-void MaybeSignalAnchorUse(int error,
-                          const base::Closure& anchor_used_callback,
-                          const net::CertVerifyResult& verify_result) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  if (error != net::OK || !verify_result.is_issued_by_additional_trust_anchor ||
-      anchor_used_callback.is_null()) {
-    return;
-  }
-  anchor_used_callback.Run();
-}
-
-void CompleteAndSignalAnchorUse(
-    const base::Closure& anchor_used_callback,
-    const net::CompletionCallback& completion_callback,
-    const net::CertVerifyResult* verify_result,
-    int error) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  MaybeSignalAnchorUse(error, anchor_used_callback, *verify_result);
-  if (!completion_callback.is_null())
-    completion_callback.Run(error);
-}
-
-}  // namespace
-
 PolicyCertVerifier::PolicyCertVerifier(
     const base::Closure& anchor_used_callback)
-    : anchor_used_callback_(anchor_used_callback) {
+    : anchor_used_callback_(anchor_used_callback),
+      weak_ptr_factory_(this),
+      weak_ptr_(weak_ptr_factory_.GetWeakPtr()) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 }
 
 PolicyCertVerifier::~PolicyCertVerifier() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  DCHECK(!weak_ptr_factory_.HasWeakPtrs())
+      << "UnsetTrustAnchorUsedCallback must be called before d'tor. " << this;
 }
 
 void PolicyCertVerifier::InitializeOnIOThread() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   scoped_refptr<net::CertVerifyProc> verify_proc =
       net::CertVerifyProc::CreateDefault();
   if (!verify_proc->SupportsAdditionalTrustAnchors()) {
     LOG(WARNING)
-        << "Additional trust anchors not supported in the current platform!";
+        << "Additional trust anchors not supported on the current platform!";
   }
   net::MultiThreadedCertVerifier* verifier =
       new net::MultiThreadedCertVerifier(verify_proc.get());
   verifier->SetCertTrustAnchorProvider(this);
   delegate_.reset(verifier);
 }
 
+void PolicyCertVerifier::UnsetTrustAnchorUsedCallback() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  anchor_used_callback_.Reset();
+  weak_ptr_factory_.InvalidateWeakPtrs();
+}
+
 void PolicyCertVerifier::SetTrustAnchors(
     const net::CertificateList& trust_anchors) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   trust_anchors_ = trust_anchors;
 }
 
 int PolicyCertVerifier::Verify(
     net::X509Certificate* cert,
     const std::string& hostname,
     int flags,
     net::CRLSet* crl_set,
     net::CertVerifyResult* verify_result,
     const net::CompletionCallback& completion_callback,
     RequestHandle* out_req,
     const net::BoundNetLog& net_log) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   DCHECK(delegate_);
   net::CompletionCallback wrapped_callback =
-      base::Bind(&CompleteAndSignalAnchorUse,
-                 anchor_used_callback_,
+      base::Bind(&PolicyCertVerifier::CompleteAndSignalAnchorUse,
                  completion_callback,
-                 verify_result);
+                 verify_result,
+                 weak_ptr_);
   int error = delegate_->Verify(cert, hostname, flags, crl_set, verify_result,
                                 wrapped_callback, out_req, net_log);
-  MaybeSignalAnchorUse(error, anchor_used_callback_, *verify_result);
+  MaybeSignalAnchorUse(error, *verify_result, weak_ptr_);
   return error;
 }
 
 void PolicyCertVerifier::CancelRequest(RequestHandle req) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   delegate_->CancelRequest(req);
 }
 
 const net::CertificateList& PolicyCertVerifier::GetAdditionalTrustAnchors() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   return trust_anchors_;
 }
 
+void PolicyCertVerifier::NotifyOnUI() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!anchor_used_callback_.is_null())
+    anchor_used_callback_.Run();
+}
+
+// static
+void PolicyCertVerifier::MaybeSignalAnchorUse(
+    int error,
+    const net::CertVerifyResult& verify_result,
+    const base::WeakPtr<PolicyCertVerifier>& weak_ptr) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  if (error != net::OK || !verify_result.is_issued_by_additional_trust_anchor)
+    return;
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&PolicyCertVerifier::NotifyOnUI, weak_ptr));
+}
+
+// static
+void PolicyCertVerifier::CompleteAndSignalAnchorUse(
+    const net::CompletionCallback& completion_callback,
+    const net::CertVerifyResult* verify_result,
+    const base::WeakPtr<PolicyCertVerifier>& weak_ptr,
+    int error) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  MaybeSignalAnchorUse(error, *verify_result, weak_ptr);
+  if (!completion_callback.is_null())
+    completion_callback.Run(error);
+}
+
 }  // namespace policy