Fix cyclic dependency between ProfilePolicyConnector and PrefService.

chrome/browser/chromeos/policy/policy_cert_service.cc

+// Copyright 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_service.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/logging.h"
+#include "base/prefs/pref_service.h"
+#include "chrome/browser/chromeos/policy/policy_cert_verifier.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/cert/x509_certificate.h"
+
+namespace policy {
+
+PolicyCertService::~PolicyCertService() {
+  DCHECK(cert_verifier_)
+      << "CreatePolicyCertVerifier() must be called after construction.";
+}
+
+PolicyCertService::PolicyCertService(
+    UserNetworkConfigurationUpdater* net_conf_updater,
+    PrefService* user_prefs)
+    : cert_verifier_(NULL),
+      net_conf_updater_(net_conf_updater),
+      user_prefs_(user_prefs),
+      weak_ptr_factory_(this) {
+  DCHECK(net_conf_updater_);
+  DCHECK(user_prefs_);
+}
+
+scoped_ptr<PolicyCertVerifier> PolicyCertService::CreatePolicyCertVerifier() {
+  base::Closure callback =
+      base::Bind(&PolicyCertService::SetUsedPolicyCertificatesOnce,
+                 weak_ptr_factory_.GetWeakPtr());
+  cert_verifier_ = new PolicyCertVerifier(
+      base::Bind(base::IgnoreResult(&content::BrowserThread::PostTask),
+                 content::BrowserThread::UI,
+                 FROM_HERE,
+                 callback));
+  // Certs are forwarded to |cert_verifier_|, thus register here after
+  // |cert_verifier_| is created.
+  net_conf_updater_->AddTrustedCertsObserver(this);
+
+  // Set the current list of trust anchors.
+  net::CertificateList trust_anchors;
+  net_conf_updater_->GetWebTrustedCertificates(&trust_anchors);
+  OnTrustAnchorsChanged(trust_anchors);
+
+  return make_scoped_ptr(cert_verifier_);
+}
+
+void PolicyCertService::OnTrustAnchorsChanged(
+    const net::CertificateList& trust_anchors) {
+  DCHECK(cert_verifier_);
+  // It's safe to use base::Unretained here, because it's guaranteed that
+  // |cert_verifier_| outlives this object (see description of
+  // CreatePolicyCertVerifier).
+  // Note: ProfileIOData, which owns the CertVerifier is deleted by a
+  // DeleteSoon on IO, i.e. after all pending tasks on IO are finished.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&PolicyCertVerifier::SetTrustAnchors,
+                 base::Unretained(cert_verifier_),
+                 trust_anchors));
+}
+
+bool PolicyCertService::UsedPolicyCertificates() const {
+  return user_prefs_->GetBoolean(prefs::kUsedPolicyCertificatesOnce);
+}
+
+void PolicyCertService::Shutdown() {
+  weak_ptr_factory_.InvalidateWeakPtrs();
+  net_conf_updater_->RemoveTrustedCertsObserver(this);
+  OnTrustAnchorsChanged(net::CertificateList());
+  net_conf_updater_ = NULL;
+  user_prefs_ = NULL;
+}
+
+void PolicyCertService::SetUsedPolicyCertificatesOnce() {
+  user_prefs_->SetBoolean(prefs::kUsedPolicyCertificatesOnce, true);
+}
+
+}  // namespace policy