Cosmetic cleanups in chrome/browser/policy/

chrome/browser/policy/configuration_policy_reader.cc

 // Copyright (c) 2011 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/policy/configuration_policy_reader.h"
 
 #include <map>
 #include <vector>
 
+#include "base/logging.h"
 #include "base/stl_util.h"
+#include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/policy_map.h"
 
 namespace policy {
 
 // This class functions as a container for policy status information used by the
 // ConfigurationPolicyReader class. It obtains policy values from a
@@ skipping 49 matching lines @@
 
 void ConfigurationPolicyStatusKeeper::GetPoliciesFromProvider(
     ConfigurationPolicyProvider* provider) {
   scoped_ptr<PolicyMap> policies(new PolicyMap());
   if (!provider->Provide(policies.get()))
     LOG(WARNING) << "Failed to get policy from provider.";
 
   PolicyMap::const_iterator policy = policies->begin();
   for ( ; policy != policies->end(); ++policy) {
     string16 name = PolicyStatus::GetPolicyName(policy->first);
-
-    if (name == string16()) {
-      NOTREACHED();
-    }
+    DCHECK(!name.empty());
 
     // TODO(simo) actually determine whether the policy is a user or a device
     // one and whether the policy could be enforced or not once this information
     // is available.
     PolicyStatusInfo* info = new PolicyStatusInfo(name,
                                                   PolicyStatusInfo::USER,
                                                   policy_level_,
                                                   policy->second->DeepCopy(),
                                                   PolicyStatusInfo::ENFORCED,
                                                   string16());
@@ skipping 52 matching lines @@
       connector->GetManagedCloudProvider(), PolicyStatusInfo::MANDATORY);
 }
 
 // static
 ConfigurationPolicyReader*
     ConfigurationPolicyReader::CreateRecommendedPlatformPolicyReader() {
   BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   return new ConfigurationPolicyReader(
       connector->GetRecommendedPlatformProvider(),
-          PolicyStatusInfo::RECOMMENDED);
+      PolicyStatusInfo::RECOMMENDED);
 }
 
 // static
 ConfigurationPolicyReader*
     ConfigurationPolicyReader::CreateRecommendedCloudPolicyReader() {
   BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   return new ConfigurationPolicyReader(
       connector->GetRecommendedCloudProvider(), PolicyStatusInfo::RECOMMENDED);
 }
 
 DictionaryValue* ConfigurationPolicyReader::GetPolicyStatus(
     ConfigurationPolicyType policy) const {
   return policy_keeper_->GetPolicyStatus(policy);
 }
 
 ConfigurationPolicyReader::ConfigurationPolicyReader()
     : provider_(NULL),
       policy_level_(PolicyStatusInfo::LEVEL_UNDEFINED),
       policy_keeper_(NULL) {
 }
 
 void ConfigurationPolicyReader::Refresh() {
   if (!provider_)
     return;
 
-  // Read policy state into a new keeper and swap out old keeper.
-  scoped_ptr<ConfigurationPolicyStatusKeeper> new_keeper(
+  policy_keeper_.reset(
       new ConfigurationPolicyStatusKeeper(provider_, policy_level_));
-  policy_keeper_.reset(new_keeper.release());
 
   FOR_EACH_OBSERVER(Observer, observers_, OnPolicyValuesChanged());
 }
 
 // PolicyStatus
 PolicyStatus::PolicyStatus(ConfigurationPolicyReader* managed_platform,
                            ConfigurationPolicyReader* managed_cloud,
                            ConfigurationPolicyReader* recommended_platform,
                            ConfigurationPolicyReader* recommended_cloud)
     : managed_platform_(managed_platform),
@@ skipping 46 matching lines @@
   for ( ; info != unsent_policies.end(); ++info)
     result->Append(*info);
 
   return result;
 }
 
 // static
 string16 PolicyStatus::GetPolicyName(ConfigurationPolicyType policy_type) {
   static std::map<ConfigurationPolicyType, string16> name_map;
   static const ConfigurationPolicyProvider::PolicyDefinitionList*
-      supported_policies;
+      supported_policies = NULL;
 
   if (!supported_policies) {
     supported_policies =
         ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList();
 
     // Create mapping from ConfigurationPolicyTypes to actual policy names.
     const ConfigurationPolicyProvider::PolicyDefinitionList::Entry* entry =
         supported_policies->begin;
     for ( ; entry != supported_policies->end; ++entry)
       name_map[entry->policy_type] = ASCIIToUTF16(entry->name);
@@ skipping 27 matching lines @@
     list->Append(mc_policy);
   if (rp_policy)
     list->Append(rp_policy);
   if (rc_policy)
     list->Append(rc_policy);
 
   return added_policy;
 }
 
 } // namespace policy