src/chrome/browser/policy/policy_error_map.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/policy/policy_error_map.h"
   6
   7 #include <utility>
   8
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "grit/generated_resources.h"
  13 #include "ui/base/l10n/l10n_util.h"
  14 #include "ui/base/resource/resource_bundle.h"
  15
  16 namespace policy {
  17
  18 struct PolicyErrorMap::PendingError {
  19   PendingError(const std::string& policy,
  20                const std::string& subkey,
  21                int index,
  22                int message_id,
  23                const std::string& replacement)
  24       : policy(policy),
  25         subkey(subkey),
  26         index(index),
  27         message_id(message_id),
  28         has_replacement(true),
  29         replacement(replacement) {}
  30
  31   PendingError(const std::string& policy,
  32                const std::string& subkey,
  33                int index,
  34                int message_id)
  35       : policy(policy),
  36         subkey(subkey),
  37         index(index),
  38         message_id(message_id),
  39         has_replacement(false) {}
  40
  41   std::string policy;
  42   std::string subkey;
  43   int index;
  44   int message_id;
  45   bool has_replacement;
  46   std::string replacement;
  47 };
  48
  49 PolicyErrorMap::PolicyErrorMap() {
  50 }
  51
  52 PolicyErrorMap::~PolicyErrorMap() {
  53 }
  54
  55 bool PolicyErrorMap::IsReady() const {
  56   return ui::ResourceBundle::HasSharedInstance();
  57 }
  58
  59 void PolicyErrorMap::AddError(const std::string& policy, int message_id) {
  60   AddError(PendingError(policy, std::string(), -1, message_id));
  61 }
  62
  63 void PolicyErrorMap::AddError(const std::string& policy,
  64                               const std::string& subkey,
  65                               int message_id) {
  66   AddError(PendingError(policy, subkey, -1, message_id));
  67 }
  68
  69 void PolicyErrorMap::AddError(const std::string& policy,
  70                               int index,
  71                               int message_id) {
  72   AddError(PendingError(policy, std::string(), index, message_id));
  73 }
  74
  75 void PolicyErrorMap::AddError(const std::string& policy,
  76                               int message_id,
  77                               const std::string& replacement) {
  78   AddError(PendingError(policy, std::string(), -1, message_id, replacement));
  79 }
  80
  81 void PolicyErrorMap::AddError(const std::string& policy,
  82                               const std::string& subkey,
  83                               int message_id,
  84                               const std::string& replacement) {
  85   AddError(PendingError(policy, subkey, -1, message_id, replacement));
  86 }
  87
  88 void PolicyErrorMap::AddError(const std::string& policy,
  89                               int index,
  90                               int message_id,
  91                               const std::string& replacement) {
  92   AddError(PendingError(policy, std::string(), index, message_id, replacement));
  93 }
  94
  95 string16 PolicyErrorMap::GetErrors(const std::string& policy) {
  96   CheckReadyAndConvert();
  97   std::pair<const_iterator, const_iterator> range = map_.equal_range(policy);
  98   std::vector<string16> list;
  99   for (const_iterator it = range.first; it != range.second; ++it)
 100     list.push_back(it->second);
 101   return JoinString(list, '\n');
 102 }
 103
 104 bool PolicyErrorMap::empty() {
 105   CheckReadyAndConvert();
 106   return map_.empty();
 107 }
 108
 109 size_t PolicyErrorMap::size() {
 110   CheckReadyAndConvert();
 111   return map_.size();
 112 }
 113
 114 PolicyErrorMap::const_iterator PolicyErrorMap::begin() {
 115   CheckReadyAndConvert();
 116   return map_.begin();
 117 }
 118
 119 PolicyErrorMap::const_iterator PolicyErrorMap::end() {
 120   CheckReadyAndConvert();
 121   return map_.end();
 122 }
 123
 124 void PolicyErrorMap::Clear() {
 125   CheckReadyAndConvert();
 126   map_.clear();
 127 }
 128
 129 void PolicyErrorMap::AddError(const PendingError& error) {
 130   if (IsReady()) {
 131     Convert(error);
 132   } else {
 133     pending_.push_back(error);
 134   }
 135 }
 136
 137 void PolicyErrorMap::Convert(const PendingError& error) {
 138   string16 submessage;
 139   if (error.has_replacement) {
 140     submessage = l10n_util::GetStringFUTF16(error.message_id,
 141                                             ASCIIToUTF16(error.replacement));
 142   } else {
 143     submessage = l10n_util::GetStringUTF16(error.message_id);
 144   }
 145   string16 message;
 146   if (!error.subkey.empty()) {
 147     message = l10n_util::GetStringFUTF16(IDS_POLICY_SUBKEY_ERROR,
 148                                          ASCIIToUTF16(error.subkey),
 149                                          submessage);
 150   } else if (error.index >= 0) {
 151     message = l10n_util::GetStringFUTF16(IDS_POLICY_LIST_ENTRY_ERROR,
 152                                          base::IntToString16(error.index),
 153                                          submessage);
 154   } else {
 155     message = submessage;
 156   }
 157   map_.insert(std::make_pair(error.policy, message));
 158 }
 159
 160 void PolicyErrorMap::CheckReadyAndConvert() {
 161   DCHECK(IsReady());
 162   for (size_t i = 0; i < pending_.size(); ++i) {
 163     Convert(pending_[i]);
 164   }
 165   pending_.clear();
 166 }
 167
 168 }  // namespace policy