Adding policy support to the new network configuration stack.

chrome/browser/chromeos/policy/network_configuration_updater_impl_cros.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 "chrome/browser/chromeos/policy/network_configuration_updater.h"
+#include "chrome/browser/chromeos/policy/network_configuration_updater_impl_cros.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/policy/policy_map.h"
@@ skipping 30 matching lines @@
   }
 
  private:
   net::CertificateList trust_anchors_;
 
   DISALLOW_COPY_AND_ASSIGN(CrosTrustAnchorProvider);
 };
 
 }  // namespace
 
-NetworkConfigurationUpdater::NetworkConfigurationUpdater(
+NetworkConfigurationUpdaterImplCros::NetworkConfigurationUpdaterImplCros(
     PolicyService* policy_service,
     chromeos::NetworkLibrary* network_library)
     : policy_change_registrar_(
           policy_service, PolicyNamespace(POLICY_DOMAIN_CHROME, std::string())),
       network_library_(network_library),
       user_policy_initialized_(false),
       allow_trusted_certificates_from_policy_(false),
       policy_service_(policy_service),
       cert_trust_provider_(new CrosTrustAnchorProvider()) {
   DCHECK(network_library_);
   policy_change_registrar_.Observe(
       key::kDeviceOpenNetworkConfiguration,
-      base::Bind(&NetworkConfigurationUpdater::OnPolicyChanged,
+      base::Bind(&NetworkConfigurationUpdaterImplCros::OnPolicyChanged,
                  base::Unretained(this),
                  chromeos::onc::ONC_SOURCE_DEVICE_POLICY));
   policy_change_registrar_.Observe(
       key::kOpenNetworkConfiguration,
-      base::Bind(&NetworkConfigurationUpdater::OnPolicyChanged,
+      base::Bind(&NetworkConfigurationUpdaterImplCros::OnPolicyChanged,
                  base::Unretained(this),
                  chromeos::onc::ONC_SOURCE_USER_POLICY));
 
   network_library_->AddNetworkProfileObserver(this);
 
   // Apply the current policies immediately.
   ApplyNetworkConfigurations();
 }
 
-NetworkConfigurationUpdater::~NetworkConfigurationUpdater() {
+NetworkConfigurationUpdaterImplCros::~NetworkConfigurationUpdaterImplCros() {
   network_library_->RemoveNetworkProfileObserver(this);
   bool posted = BrowserThread::DeleteSoon(
       BrowserThread::IO, FROM_HERE, cert_trust_provider_);
   if (!posted)
     delete cert_trust_provider_;
 }
 
-void NetworkConfigurationUpdater::OnProfileListChanged() {
+void NetworkConfigurationUpdaterImplCros::OnProfileListChanged() {
   VLOG(1) << "Network profile list changed, applying policies.";
   ApplyNetworkConfigurations();
 }
 
-void NetworkConfigurationUpdater::OnUserPolicyInitialized() {
+void NetworkConfigurationUpdaterImplCros::OnUserPolicyInitialized() {
   VLOG(1) << "User policy initialized, applying policies.";
   user_policy_initialized_ = true;
   ApplyNetworkConfigurations();
 }
 
+void NetworkConfigurationUpdaterImplCros::
+set_allow_trusted_certificates_from_policy(bool allow) {
+  allow_trusted_certificates_from_policy_ = allow;
+}
+
 net::CertTrustAnchorProvider*
-    NetworkConfigurationUpdater::GetCertTrustAnchorProvider() {
+    NetworkConfigurationUpdaterImplCros::GetCertTrustAnchorProvider() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return cert_trust_provider_;
 }
 
-void NetworkConfigurationUpdater::OnPolicyChanged(
+void NetworkConfigurationUpdaterImplCros::OnPolicyChanged(
     chromeos::onc::ONCSource onc_source,
     const base::Value* previous,
     const base::Value* current) {
   VLOG(1) << "Policy for ONC source "
           << chromeos::onc::GetSourceAsString(onc_source) << " changed.";
   ApplyNetworkConfigurations();
 }
 
-void NetworkConfigurationUpdater::ApplyNetworkConfigurations() {
+void NetworkConfigurationUpdaterImplCros::ApplyNetworkConfigurations() {
   ApplyNetworkConfiguration(key::kDeviceOpenNetworkConfiguration,
                             chromeos::onc::ONC_SOURCE_DEVICE_POLICY);
   if (user_policy_initialized_) {
     ApplyNetworkConfiguration(key::kOpenNetworkConfiguration,
                               chromeos::onc::ONC_SOURCE_USER_POLICY);
   }
 }
 
-void NetworkConfigurationUpdater::ApplyNetworkConfiguration(
+void NetworkConfigurationUpdaterImplCros::ApplyNetworkConfiguration(
     const std::string& policy_key,
     chromeos::onc::ONCSource onc_source) {
   VLOG(1) << "Apply policy for ONC source "
           << chromeos::onc::GetSourceAsString(onc_source);
   const PolicyMap& policies = policy_service_->GetPolicies(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   const base::Value* policy_value = policies.GetValue(policy_key);
 
   std::string new_network_config;
   if (policy_value != NULL) {
@@ skipping 24 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&CrosTrustAnchorProvider::SetTrustAnchors,
                    base::Unretained(static_cast<CrosTrustAnchorProvider*>(
                        cert_trust_provider_)),
                    base::Passed(&web_trust_certs)));
   }
 }
 
 }  // namespace policy