components/login/screens/screen_context.cc

   1 // Copyright (c) 2013 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 "components/login/screens/screen_context.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9
  10 namespace login {
  11
  12 namespace {
  13
  14 template <typename StringListType>
  15 base::ListValue* StringListToListValue(const StringListType& list) {
  16   base::ListValue* result = new base::ListValue();
  17   for (typename StringListType::const_iterator it = list.begin();
  18        it != list.end();
  19        ++it) {
  20     result->AppendString(*it);
  21   }
  22   return result;
  23 }
  24
  25 }  // namespace
  26
  27 ScreenContext::ScreenContext() {
  28 }
  29
  30 ScreenContext::~ScreenContext() {
  31 }
  32
  33 bool ScreenContext::SetBoolean(const KeyType& key, bool value) {
  34   return Set(key, new base::FundamentalValue(value));
  35 }
  36
  37 bool ScreenContext::SetInteger(const KeyType& key, int value) {
  38   return Set(key, new base::FundamentalValue(value));
  39 }
  40
  41 bool ScreenContext::SetDouble(const KeyType& key, double value) {
  42   return Set(key, new base::FundamentalValue(value));
  43 }
  44
  45 bool ScreenContext::SetString(const KeyType& key, const std::string& value) {
  46   return Set(key, new base::StringValue(value));
  47 }
  48
  49 bool ScreenContext::SetString(const KeyType& key, const base::string16& value) {
  50   return Set(key, new base::StringValue(value));
  51 }
  52
  53 bool ScreenContext::SetStringList(const KeyType& key, const StringList& value) {
  54   return Set(key, StringListToListValue(value));
  55 }
  56
  57 bool ScreenContext::SetString16List(const KeyType& key,
  58                                     const String16List& value) {
  59   return Set(key, StringListToListValue(value));
  60 }
  61
  62 bool ScreenContext::GetBoolean(const KeyType& key) const {
  63   return Get<bool>(key);
  64 }
  65
  66 bool ScreenContext::GetBoolean(const KeyType& key, bool default_value) const {
  67   return Get(key, default_value);
  68 }
  69
  70 int ScreenContext::GetInteger(const KeyType& key) const {
  71   return Get<int>(key);
  72 }
  73
  74 int ScreenContext::GetInteger(const KeyType& key, int default_value) const {
  75   return Get(key, default_value);
  76 }
  77
  78 double ScreenContext::GetDouble(const KeyType& key) const {
  79   return Get<double>(key);
  80 }
  81
  82 double ScreenContext::GetDouble(const KeyType& key,
  83                                 double default_value) const {
  84   return Get(key, default_value);
  85 }
  86
  87 std::string ScreenContext::GetString(const KeyType& key) const {
  88   return Get<std::string>(key);
  89 }
  90
  91 std::string ScreenContext::GetString(const KeyType& key,
  92                                      const std::string& default_value) const {
  93   return Get(key, default_value);
  94 }
  95
  96 base::string16 ScreenContext::GetString16(const KeyType& key) const {
  97   return Get<base::string16>(key);
  98 }
  99
 100 base::string16 ScreenContext::GetString16(
 101     const KeyType& key,
 102     const base::string16& default_value) const {
 103   return Get(key, default_value);
 104 }
 105
 106 StringList ScreenContext::GetStringList(const KeyType& key) const {
 107   return Get<StringList>(key);
 108 }
 109
 110 StringList ScreenContext::GetStringList(const KeyType& key,
 111                                         const StringList& default_value) const {
 112   return Get(key, default_value);
 113 }
 114
 115 String16List ScreenContext::GetString16List(const KeyType& key) const {
 116   return Get<String16List>(key);
 117 }
 118
 119 String16List ScreenContext::GetString16List(
 120     const KeyType& key,
 121     const String16List& default_value) const {
 122   return Get(key, default_value);
 123 }
 124
 125 void ScreenContext::CopyFrom(ScreenContext& context) {
 126   scoped_ptr<base::DictionaryValue> storage(context.storage_.DeepCopy());
 127   scoped_ptr<base::DictionaryValue> changes(context.changes_.DeepCopy());
 128   storage_.Swap(storage.get());
 129   changes_.Swap(changes.get());
 130 }
 131
 132 bool ScreenContext::HasKey(const KeyType& key) const {
 133   DCHECK(CalledOnValidThread());
 134   return storage_.HasKey(key);
 135 }
 136
 137 bool ScreenContext::HasChanges() const {
 138   DCHECK(CalledOnValidThread());
 139   return !changes_.empty();
 140 }
 141
 142 void ScreenContext::GetChangesAndReset(base::DictionaryValue* diff) {
 143   DCHECK(CalledOnValidThread());
 144   DCHECK(diff);
 145   changes_.Swap(diff);
 146   changes_.Clear();
 147 }
 148
 149 void ScreenContext::ApplyChanges(const base::DictionaryValue& diff,
 150                                  std::vector<std::string>* keys) {
 151   DCHECK(CalledOnValidThread());
 152   DCHECK(!HasChanges());
 153   if (keys) {
 154     keys->clear();
 155     keys->reserve(diff.size());
 156   }
 157
 158   for (base::DictionaryValue::Iterator it(diff); !it.IsAtEnd(); it.Advance()) {
 159     Set(it.key(), it.value().DeepCopy());
 160     if (keys)
 161       keys->push_back(it.key());
 162   }
 163   changes_.Clear();
 164 }
 165
 166 bool ScreenContext::Set(const KeyType& key, base::Value* value) {
 167   DCHECK(CalledOnValidThread());
 168   DCHECK(value);
 169   scoped_ptr<base::Value> new_value(value);
 170
 171   base::Value* current_value;
 172   bool in_storage = storage_.Get(key, &current_value);
 173
 174   // Don't do anything if |storage_| already contains <|key|, |new_value|> pair.
 175   if (in_storage && new_value->Equals(current_value))
 176     return false;
 177
 178   changes_.Set(key, new_value->DeepCopy());
 179   storage_.Set(key, new_value.release());
 180   return true;
 181 }
 182
 183 }  // namespace login