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 "base/values.h"
6
7 #include <string.h>
8
9 #include <algorithm>
10 #include <cmath>
11 #include <ostream>
12 #include <utility>
13
14 #include "base/json/json_writer.h"
15 #include "base/logging.h"
16 #include "base/move.h"
17 #include "base/strings/string_util.h"
18 #include "base/strings/utf_string_conversions.h"
19
20 namespace base {
21
22 namespace {
23
24 scoped_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
25
26 // Make a deep copy of |node|, but don't include empty lists or dictionaries
27 // in the copy. It's possible for this function to return NULL and it
28 // expects |node| to always be non-NULL.
CopyListWithoutEmptyChildren(const ListValue & list)29 scoped_ptr<ListValue> CopyListWithoutEmptyChildren(const ListValue& list) {
30 scoped_ptr<ListValue> copy;
31 for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) {
32 scoped_ptr<Value> child_copy = CopyWithoutEmptyChildren(**it);
33 if (child_copy) {
34 if (!copy)
35 copy.reset(new ListValue);
36 copy->Append(std::move(child_copy));
37 }
38 }
39 return copy;
40 }
41
CopyDictionaryWithoutEmptyChildren(const DictionaryValue & dict)42 scoped_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
43 const DictionaryValue& dict) {
44 scoped_ptr<DictionaryValue> copy;
45 for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
46 scoped_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
47 if (child_copy) {
48 if (!copy)
49 copy.reset(new DictionaryValue);
50 copy->SetWithoutPathExpansion(it.key(), std::move(child_copy));
51 }
52 }
53 return copy;
54 }
55
CopyWithoutEmptyChildren(const Value & node)56 scoped_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
57 switch (node.GetType()) {
58 case Value::TYPE_LIST:
59 return CopyListWithoutEmptyChildren(static_cast<const ListValue&>(node));
60
61 case Value::TYPE_DICTIONARY:
62 return CopyDictionaryWithoutEmptyChildren(
63 static_cast<const DictionaryValue&>(node));
64
65 default:
66 return node.CreateDeepCopy();
67 }
68 }
69
70 // A small functor for comparing Values for std::find_if and similar.
71 class ValueEquals {
72 public:
73 // Pass the value against which all consecutive calls of the () operator will
74 // compare their argument to. This Value object must not be destroyed while
75 // the ValueEquals is in use.
ValueEquals(const Value * first)76 explicit ValueEquals(const Value* first) : first_(first) { }
77
operator ()(const Value * second) const78 bool operator ()(const Value* second) const {
79 return first_->Equals(second);
80 }
81
82 private:
83 const Value* first_;
84 };
85
86 } // namespace
87
~Value()88 Value::~Value() {
89 }
90
91 // static
CreateNullValue()92 scoped_ptr<Value> Value::CreateNullValue() {
93 return make_scoped_ptr(new Value(TYPE_NULL));
94 }
95
GetAsBinary(const BinaryValue **) const96 bool Value::GetAsBinary(const BinaryValue** /* out_value */) const {
97 return false;
98 }
99
GetAsBoolean(bool *) const100 bool Value::GetAsBoolean(bool* /* out_value */) const {
101 return false;
102 }
103
GetAsInteger(int *) const104 bool Value::GetAsInteger(int* /* out_value */) const {
105 return false;
106 }
107
GetAsDouble(double *) const108 bool Value::GetAsDouble(double* /* out_value */) const {
109 return false;
110 }
111
GetAsString(std::string *) const112 bool Value::GetAsString(std::string* /* out_value */) const {
113 return false;
114 }
115
GetAsString(string16 *) const116 bool Value::GetAsString(string16* /* out_value */) const {
117 return false;
118 }
119
GetAsString(const StringValue **) const120 bool Value::GetAsString(const StringValue** /* out_value */) const {
121 return false;
122 }
123
GetAsList(ListValue **)124 bool Value::GetAsList(ListValue** /* out_value */) {
125 return false;
126 }
127
GetAsList(const ListValue **) const128 bool Value::GetAsList(const ListValue** /* out_value */) const {
129 return false;
130 }
131
GetAsDictionary(DictionaryValue **)132 bool Value::GetAsDictionary(DictionaryValue** /* out_value */) {
133 return false;
134 }
135
GetAsDictionary(const DictionaryValue **) const136 bool Value::GetAsDictionary(const DictionaryValue** /* out_value */) const {
137 return false;
138 }
139
DeepCopy() const140 Value* Value::DeepCopy() const {
141 // This method should only be getting called for null Values--all subclasses
142 // need to provide their own implementation;.
143 DCHECK(IsType(TYPE_NULL));
144 return CreateNullValue().release();
145 }
146
CreateDeepCopy() const147 scoped_ptr<Value> Value::CreateDeepCopy() const {
148 return make_scoped_ptr(DeepCopy());
149 }
150
Equals(const Value * other) const151 bool Value::Equals(const Value* other) const {
152 // This method should only be getting called for null Values--all subclasses
153 // need to provide their own implementation;.
154 DCHECK(IsType(TYPE_NULL));
155 return other->IsType(TYPE_NULL);
156 }
157
158 // static
Equals(const Value * a,const Value * b)159 bool Value::Equals(const Value* a, const Value* b) {
160 if ((a == NULL) && (b == NULL)) return true;
161 if ((a == NULL) ^ (b == NULL)) return false;
162 return a->Equals(b);
163 }
164
Value(Type type)165 Value::Value(Type type) : type_(type) {}
166
Value(const Value & that)167 Value::Value(const Value& that) : type_(that.type_) {}
168
operator =(const Value & that)169 Value& Value::operator=(const Value& that) {
170 type_ = that.type_;
171 return *this;
172 }
173
174 ///////////////////// FundamentalValue ////////////////////
175
FundamentalValue(bool in_value)176 FundamentalValue::FundamentalValue(bool in_value)
177 : Value(TYPE_BOOLEAN), boolean_value_(in_value) {
178 }
179
FundamentalValue(int in_value)180 FundamentalValue::FundamentalValue(int in_value)
181 : Value(TYPE_INTEGER), integer_value_(in_value) {
182 }
183
FundamentalValue(double in_value)184 FundamentalValue::FundamentalValue(double in_value)
185 : Value(TYPE_DOUBLE), double_value_(in_value) {
186 if (!std::isfinite(double_value_)) {
187 NOTREACHED() << "Non-finite (i.e. NaN or positive/negative infinity) "
188 << "values cannot be represented in JSON";
189 double_value_ = 0.0;
190 }
191 }
192
~FundamentalValue()193 FundamentalValue::~FundamentalValue() {
194 }
195
GetAsBoolean(bool * out_value) const196 bool FundamentalValue::GetAsBoolean(bool* out_value) const {
197 if (out_value && IsType(TYPE_BOOLEAN))
198 *out_value = boolean_value_;
199 return (IsType(TYPE_BOOLEAN));
200 }
201
GetAsInteger(int * out_value) const202 bool FundamentalValue::GetAsInteger(int* out_value) const {
203 if (out_value && IsType(TYPE_INTEGER))
204 *out_value = integer_value_;
205 return (IsType(TYPE_INTEGER));
206 }
207
GetAsDouble(double * out_value) const208 bool FundamentalValue::GetAsDouble(double* out_value) const {
209 if (out_value && IsType(TYPE_DOUBLE))
210 *out_value = double_value_;
211 else if (out_value && IsType(TYPE_INTEGER))
212 *out_value = integer_value_;
213 return (IsType(TYPE_DOUBLE) || IsType(TYPE_INTEGER));
214 }
215
DeepCopy() const216 FundamentalValue* FundamentalValue::DeepCopy() const {
217 switch (GetType()) {
218 case TYPE_BOOLEAN:
219 return new FundamentalValue(boolean_value_);
220
221 case TYPE_INTEGER:
222 return new FundamentalValue(integer_value_);
223
224 case TYPE_DOUBLE:
225 return new FundamentalValue(double_value_);
226
227 default:
228 NOTREACHED();
229 return NULL;
230 }
231 }
232
Equals(const Value * other) const233 bool FundamentalValue::Equals(const Value* other) const {
234 if (other->GetType() != GetType())
235 return false;
236
237 switch (GetType()) {
238 case TYPE_BOOLEAN: {
239 bool lhs, rhs;
240 return GetAsBoolean(&lhs) && other->GetAsBoolean(&rhs) && lhs == rhs;
241 }
242 case TYPE_INTEGER: {
243 int lhs, rhs;
244 return GetAsInteger(&lhs) && other->GetAsInteger(&rhs) && lhs == rhs;
245 }
246 case TYPE_DOUBLE: {
247 double lhs, rhs;
248 return GetAsDouble(&lhs) && other->GetAsDouble(&rhs) && lhs == rhs;
249 }
250 default:
251 NOTREACHED();
252 return false;
253 }
254 }
255
256 ///////////////////// StringValue ////////////////////
257
StringValue(const std::string & in_value)258 StringValue::StringValue(const std::string& in_value)
259 : Value(TYPE_STRING),
260 value_(in_value) {
261 DCHECK(IsStringUTF8(in_value));
262 }
263
StringValue(const string16 & in_value)264 StringValue::StringValue(const string16& in_value)
265 : Value(TYPE_STRING),
266 value_(UTF16ToUTF8(in_value)) {
267 }
268
~StringValue()269 StringValue::~StringValue() {
270 }
271
GetString()272 std::string* StringValue::GetString() {
273 return &value_;
274 }
275
GetString() const276 const std::string& StringValue::GetString() const {
277 return value_;
278 }
279
GetAsString(std::string * out_value) const280 bool StringValue::GetAsString(std::string* out_value) const {
281 if (out_value)
282 *out_value = value_;
283 return true;
284 }
285
GetAsString(string16 * out_value) const286 bool StringValue::GetAsString(string16* out_value) const {
287 if (out_value)
288 *out_value = UTF8ToUTF16(value_);
289 return true;
290 }
291
GetAsString(const StringValue ** out_value) const292 bool StringValue::GetAsString(const StringValue** out_value) const {
293 if (out_value)
294 *out_value = this;
295 return true;
296 }
297
DeepCopy() const298 StringValue* StringValue::DeepCopy() const {
299 return new StringValue(value_);
300 }
301
Equals(const Value * other) const302 bool StringValue::Equals(const Value* other) const {
303 if (other->GetType() != GetType())
304 return false;
305 std::string lhs, rhs;
306 return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
307 }
308
309 ///////////////////// BinaryValue ////////////////////
310
BinaryValue()311 BinaryValue::BinaryValue()
312 : Value(TYPE_BINARY),
313 size_(0) {
314 }
315
BinaryValue(scoped_ptr<char[]> buffer,size_t size)316 BinaryValue::BinaryValue(scoped_ptr<char[]> buffer, size_t size)
317 : Value(TYPE_BINARY), buffer_(std::move(buffer)), size_(size) {}
318
~BinaryValue()319 BinaryValue::~BinaryValue() {
320 }
321
322 // static
CreateWithCopiedBuffer(const char * buffer,size_t size)323 BinaryValue* BinaryValue::CreateWithCopiedBuffer(const char* buffer,
324 size_t size) {
325 char* buffer_copy = new char[size];
326 memcpy(buffer_copy, buffer, size);
327 scoped_ptr<char[]> scoped_buffer_copy(buffer_copy);
328 return new BinaryValue(std::move(scoped_buffer_copy), size);
329 }
330
GetAsBinary(const BinaryValue ** out_value) const331 bool BinaryValue::GetAsBinary(const BinaryValue** out_value) const {
332 if (out_value)
333 *out_value = this;
334 return true;
335 }
336
DeepCopy() const337 BinaryValue* BinaryValue::DeepCopy() const {
338 return CreateWithCopiedBuffer(buffer_.get(), size_);
339 }
340
Equals(const Value * other) const341 bool BinaryValue::Equals(const Value* other) const {
342 if (other->GetType() != GetType())
343 return false;
344 const BinaryValue* other_binary = static_cast<const BinaryValue*>(other);
345 if (other_binary->size_ != size_)
346 return false;
347 return !memcmp(GetBuffer(), other_binary->GetBuffer(), size_);
348 }
349
350 ///////////////////// DictionaryValue ////////////////////
351
352 // static
From(scoped_ptr<Value> value)353 scoped_ptr<DictionaryValue> DictionaryValue::From(scoped_ptr<Value> value) {
354 DictionaryValue* out;
355 if (value && value->GetAsDictionary(&out)) {
356 ignore_result(value.release());
357 return make_scoped_ptr(out);
358 }
359 return nullptr;
360 }
361
DictionaryValue()362 DictionaryValue::DictionaryValue()
363 : Value(TYPE_DICTIONARY) {
364 }
365
~DictionaryValue()366 DictionaryValue::~DictionaryValue() {
367 Clear();
368 }
369
GetAsDictionary(DictionaryValue ** out_value)370 bool DictionaryValue::GetAsDictionary(DictionaryValue** out_value) {
371 if (out_value)
372 *out_value = this;
373 return true;
374 }
375
GetAsDictionary(const DictionaryValue ** out_value) const376 bool DictionaryValue::GetAsDictionary(const DictionaryValue** out_value) const {
377 if (out_value)
378 *out_value = this;
379 return true;
380 }
381
HasKey(const std::string & key) const382 bool DictionaryValue::HasKey(const std::string& key) const {
383 DCHECK(IsStringUTF8(key));
384 ValueMap::const_iterator current_entry = dictionary_.find(key);
385 DCHECK((current_entry == dictionary_.end()) || current_entry->second);
386 return current_entry != dictionary_.end();
387 }
388
Clear()389 void DictionaryValue::Clear() {
390 ValueMap::iterator dict_iterator = dictionary_.begin();
391 while (dict_iterator != dictionary_.end()) {
392 delete dict_iterator->second;
393 ++dict_iterator;
394 }
395
396 dictionary_.clear();
397 }
398
Set(const std::string & path,scoped_ptr<Value> in_value)399 void DictionaryValue::Set(const std::string& path, scoped_ptr<Value> in_value) {
400 DCHECK(IsStringUTF8(path));
401 DCHECK(in_value);
402
403 std::string current_path(path);
404 DictionaryValue* current_dictionary = this;
405 for (size_t delimiter_position = current_path.find('.');
406 delimiter_position != std::string::npos;
407 delimiter_position = current_path.find('.')) {
408 // Assume that we're indexing into a dictionary.
409 std::string key(current_path, 0, delimiter_position);
410 DictionaryValue* child_dictionary = NULL;
411 if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
412 child_dictionary = new DictionaryValue;
413 current_dictionary->SetWithoutPathExpansion(key, child_dictionary);
414 }
415
416 current_dictionary = child_dictionary;
417 current_path.erase(0, delimiter_position + 1);
418 }
419
420 current_dictionary->SetWithoutPathExpansion(current_path,
421 std::move(in_value));
422 }
423
Set(const std::string & path,Value * in_value)424 void DictionaryValue::Set(const std::string& path, Value* in_value) {
425 Set(path, make_scoped_ptr(in_value));
426 }
427
SetBoolean(const std::string & path,bool in_value)428 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
429 Set(path, new FundamentalValue(in_value));
430 }
431
SetInteger(const std::string & path,int in_value)432 void DictionaryValue::SetInteger(const std::string& path, int in_value) {
433 Set(path, new FundamentalValue(in_value));
434 }
435
SetDouble(const std::string & path,double in_value)436 void DictionaryValue::SetDouble(const std::string& path, double in_value) {
437 Set(path, new FundamentalValue(in_value));
438 }
439
SetString(const std::string & path,const std::string & in_value)440 void DictionaryValue::SetString(const std::string& path,
441 const std::string& in_value) {
442 Set(path, new StringValue(in_value));
443 }
444
SetString(const std::string & path,const string16 & in_value)445 void DictionaryValue::SetString(const std::string& path,
446 const string16& in_value) {
447 Set(path, new StringValue(in_value));
448 }
449
SetWithoutPathExpansion(const std::string & key,scoped_ptr<Value> in_value)450 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
451 scoped_ptr<Value> in_value) {
452 Value* bare_ptr = in_value.release();
453 // If there's an existing value here, we need to delete it, because
454 // we own all our children.
455 std::pair<ValueMap::iterator, bool> ins_res =
456 dictionary_.insert(std::make_pair(key, bare_ptr));
457 if (!ins_res.second) {
458 DCHECK_NE(ins_res.first->second, bare_ptr); // This would be bogus
459 delete ins_res.first->second;
460 ins_res.first->second = bare_ptr;
461 }
462 }
463
SetWithoutPathExpansion(const std::string & key,Value * in_value)464 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
465 Value* in_value) {
466 SetWithoutPathExpansion(key, make_scoped_ptr(in_value));
467 }
468
SetBooleanWithoutPathExpansion(const std::string & path,bool in_value)469 void DictionaryValue::SetBooleanWithoutPathExpansion(
470 const std::string& path, bool in_value) {
471 SetWithoutPathExpansion(path, new FundamentalValue(in_value));
472 }
473
SetIntegerWithoutPathExpansion(const std::string & path,int in_value)474 void DictionaryValue::SetIntegerWithoutPathExpansion(
475 const std::string& path, int in_value) {
476 SetWithoutPathExpansion(path, new FundamentalValue(in_value));
477 }
478
SetDoubleWithoutPathExpansion(const std::string & path,double in_value)479 void DictionaryValue::SetDoubleWithoutPathExpansion(
480 const std::string& path, double in_value) {
481 SetWithoutPathExpansion(path, new FundamentalValue(in_value));
482 }
483
SetStringWithoutPathExpansion(const std::string & path,const std::string & in_value)484 void DictionaryValue::SetStringWithoutPathExpansion(
485 const std::string& path, const std::string& in_value) {
486 SetWithoutPathExpansion(path, new StringValue(in_value));
487 }
488
SetStringWithoutPathExpansion(const std::string & path,const string16 & in_value)489 void DictionaryValue::SetStringWithoutPathExpansion(
490 const std::string& path, const string16& in_value) {
491 SetWithoutPathExpansion(path, new StringValue(in_value));
492 }
493
Get(StringPiece path,const Value ** out_value) const494 bool DictionaryValue::Get(StringPiece path,
495 const Value** out_value) const {
496 DCHECK(IsStringUTF8(path));
497 StringPiece current_path(path);
498 const DictionaryValue* current_dictionary = this;
499 for (size_t delimiter_position = current_path.find('.');
500 delimiter_position != std::string::npos;
501 delimiter_position = current_path.find('.')) {
502 const DictionaryValue* child_dictionary = NULL;
503 if (!current_dictionary->GetDictionaryWithoutPathExpansion(
504 current_path.substr(0, delimiter_position).as_string(),
505 &child_dictionary)) {
506 return false;
507 }
508
509 current_dictionary = child_dictionary;
510 current_path = current_path.substr(delimiter_position + 1);
511 }
512
513 return current_dictionary->GetWithoutPathExpansion(current_path.as_string(),
514 out_value);
515 }
516
Get(StringPiece path,Value ** out_value)517 bool DictionaryValue::Get(StringPiece path, Value** out_value) {
518 return static_cast<const DictionaryValue&>(*this).Get(
519 path,
520 const_cast<const Value**>(out_value));
521 }
522
GetBoolean(const std::string & path,bool * bool_value) const523 bool DictionaryValue::GetBoolean(const std::string& path,
524 bool* bool_value) const {
525 const Value* value;
526 if (!Get(path, &value))
527 return false;
528
529 return value->GetAsBoolean(bool_value);
530 }
531
GetInteger(const std::string & path,int * out_value) const532 bool DictionaryValue::GetInteger(const std::string& path,
533 int* out_value) const {
534 const Value* value;
535 if (!Get(path, &value))
536 return false;
537
538 return value->GetAsInteger(out_value);
539 }
540
GetDouble(const std::string & path,double * out_value) const541 bool DictionaryValue::GetDouble(const std::string& path,
542 double* out_value) const {
543 const Value* value;
544 if (!Get(path, &value))
545 return false;
546
547 return value->GetAsDouble(out_value);
548 }
549
GetString(const std::string & path,std::string * out_value) const550 bool DictionaryValue::GetString(const std::string& path,
551 std::string* out_value) const {
552 const Value* value;
553 if (!Get(path, &value))
554 return false;
555
556 return value->GetAsString(out_value);
557 }
558
GetString(const std::string & path,string16 * out_value) const559 bool DictionaryValue::GetString(const std::string& path,
560 string16* out_value) const {
561 const Value* value;
562 if (!Get(path, &value))
563 return false;
564
565 return value->GetAsString(out_value);
566 }
567
GetStringASCII(const std::string & path,std::string * out_value) const568 bool DictionaryValue::GetStringASCII(const std::string& path,
569 std::string* out_value) const {
570 std::string out;
571 if (!GetString(path, &out))
572 return false;
573
574 if (!IsStringASCII(out)) {
575 NOTREACHED();
576 return false;
577 }
578
579 out_value->assign(out);
580 return true;
581 }
582
GetBinary(const std::string & path,const BinaryValue ** out_value) const583 bool DictionaryValue::GetBinary(const std::string& path,
584 const BinaryValue** out_value) const {
585 const Value* value;
586 bool result = Get(path, &value);
587 if (!result || !value->IsType(TYPE_BINARY))
588 return false;
589
590 if (out_value)
591 *out_value = static_cast<const BinaryValue*>(value);
592
593 return true;
594 }
595
GetBinary(const std::string & path,BinaryValue ** out_value)596 bool DictionaryValue::GetBinary(const std::string& path,
597 BinaryValue** out_value) {
598 return static_cast<const DictionaryValue&>(*this).GetBinary(
599 path,
600 const_cast<const BinaryValue**>(out_value));
601 }
602
GetDictionary(StringPiece path,const DictionaryValue ** out_value) const603 bool DictionaryValue::GetDictionary(StringPiece path,
604 const DictionaryValue** out_value) const {
605 const Value* value;
606 bool result = Get(path, &value);
607 if (!result || !value->IsType(TYPE_DICTIONARY))
608 return false;
609
610 if (out_value)
611 *out_value = static_cast<const DictionaryValue*>(value);
612
613 return true;
614 }
615
GetDictionary(StringPiece path,DictionaryValue ** out_value)616 bool DictionaryValue::GetDictionary(StringPiece path,
617 DictionaryValue** out_value) {
618 return static_cast<const DictionaryValue&>(*this).GetDictionary(
619 path,
620 const_cast<const DictionaryValue**>(out_value));
621 }
622
GetList(const std::string & path,const ListValue ** out_value) const623 bool DictionaryValue::GetList(const std::string& path,
624 const ListValue** out_value) const {
625 const Value* value;
626 bool result = Get(path, &value);
627 if (!result || !value->IsType(TYPE_LIST))
628 return false;
629
630 if (out_value)
631 *out_value = static_cast<const ListValue*>(value);
632
633 return true;
634 }
635
GetList(const std::string & path,ListValue ** out_value)636 bool DictionaryValue::GetList(const std::string& path, ListValue** out_value) {
637 return static_cast<const DictionaryValue&>(*this).GetList(
638 path,
639 const_cast<const ListValue**>(out_value));
640 }
641
GetWithoutPathExpansion(const std::string & key,const Value ** out_value) const642 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
643 const Value** out_value) const {
644 DCHECK(IsStringUTF8(key));
645 ValueMap::const_iterator entry_iterator = dictionary_.find(key);
646 if (entry_iterator == dictionary_.end())
647 return false;
648
649 const Value* entry = entry_iterator->second;
650 if (out_value)
651 *out_value = entry;
652 return true;
653 }
654
GetWithoutPathExpansion(const std::string & key,Value ** out_value)655 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
656 Value** out_value) {
657 return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
658 key,
659 const_cast<const Value**>(out_value));
660 }
661
GetBooleanWithoutPathExpansion(const std::string & key,bool * out_value) const662 bool DictionaryValue::GetBooleanWithoutPathExpansion(const std::string& key,
663 bool* out_value) const {
664 const Value* value;
665 if (!GetWithoutPathExpansion(key, &value))
666 return false;
667
668 return value->GetAsBoolean(out_value);
669 }
670
GetIntegerWithoutPathExpansion(const std::string & key,int * out_value) const671 bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
672 int* out_value) const {
673 const Value* value;
674 if (!GetWithoutPathExpansion(key, &value))
675 return false;
676
677 return value->GetAsInteger(out_value);
678 }
679
GetDoubleWithoutPathExpansion(const std::string & key,double * out_value) const680 bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
681 double* out_value) const {
682 const Value* value;
683 if (!GetWithoutPathExpansion(key, &value))
684 return false;
685
686 return value->GetAsDouble(out_value);
687 }
688
GetStringWithoutPathExpansion(const std::string & key,std::string * out_value) const689 bool DictionaryValue::GetStringWithoutPathExpansion(
690 const std::string& key,
691 std::string* out_value) const {
692 const Value* value;
693 if (!GetWithoutPathExpansion(key, &value))
694 return false;
695
696 return value->GetAsString(out_value);
697 }
698
GetStringWithoutPathExpansion(const std::string & key,string16 * out_value) const699 bool DictionaryValue::GetStringWithoutPathExpansion(const std::string& key,
700 string16* out_value) const {
701 const Value* value;
702 if (!GetWithoutPathExpansion(key, &value))
703 return false;
704
705 return value->GetAsString(out_value);
706 }
707
GetDictionaryWithoutPathExpansion(const std::string & key,const DictionaryValue ** out_value) const708 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
709 const std::string& key,
710 const DictionaryValue** out_value) const {
711 const Value* value;
712 bool result = GetWithoutPathExpansion(key, &value);
713 if (!result || !value->IsType(TYPE_DICTIONARY))
714 return false;
715
716 if (out_value)
717 *out_value = static_cast<const DictionaryValue*>(value);
718
719 return true;
720 }
721
GetDictionaryWithoutPathExpansion(const std::string & key,DictionaryValue ** out_value)722 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
723 const std::string& key,
724 DictionaryValue** out_value) {
725 const DictionaryValue& const_this =
726 static_cast<const DictionaryValue&>(*this);
727 return const_this.GetDictionaryWithoutPathExpansion(
728 key,
729 const_cast<const DictionaryValue**>(out_value));
730 }
731
GetListWithoutPathExpansion(const std::string & key,const ListValue ** out_value) const732 bool DictionaryValue::GetListWithoutPathExpansion(
733 const std::string& key,
734 const ListValue** out_value) const {
735 const Value* value;
736 bool result = GetWithoutPathExpansion(key, &value);
737 if (!result || !value->IsType(TYPE_LIST))
738 return false;
739
740 if (out_value)
741 *out_value = static_cast<const ListValue*>(value);
742
743 return true;
744 }
745
GetListWithoutPathExpansion(const std::string & key,ListValue ** out_value)746 bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
747 ListValue** out_value) {
748 return
749 static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
750 key,
751 const_cast<const ListValue**>(out_value));
752 }
753
Remove(const std::string & path,scoped_ptr<Value> * out_value)754 bool DictionaryValue::Remove(const std::string& path,
755 scoped_ptr<Value>* out_value) {
756 DCHECK(IsStringUTF8(path));
757 std::string current_path(path);
758 DictionaryValue* current_dictionary = this;
759 size_t delimiter_position = current_path.rfind('.');
760 if (delimiter_position != std::string::npos) {
761 if (!GetDictionary(current_path.substr(0, delimiter_position),
762 ¤t_dictionary))
763 return false;
764 current_path.erase(0, delimiter_position + 1);
765 }
766
767 return current_dictionary->RemoveWithoutPathExpansion(current_path,
768 out_value);
769 }
770
RemoveWithoutPathExpansion(const std::string & key,scoped_ptr<Value> * out_value)771 bool DictionaryValue::RemoveWithoutPathExpansion(const std::string& key,
772 scoped_ptr<Value>* out_value) {
773 DCHECK(IsStringUTF8(key));
774 ValueMap::iterator entry_iterator = dictionary_.find(key);
775 if (entry_iterator == dictionary_.end())
776 return false;
777
778 Value* entry = entry_iterator->second;
779 if (out_value)
780 out_value->reset(entry);
781 else
782 delete entry;
783 dictionary_.erase(entry_iterator);
784 return true;
785 }
786
RemovePath(const std::string & path,scoped_ptr<Value> * out_value)787 bool DictionaryValue::RemovePath(const std::string& path,
788 scoped_ptr<Value>* out_value) {
789 bool result = false;
790 size_t delimiter_position = path.find('.');
791
792 if (delimiter_position == std::string::npos)
793 return RemoveWithoutPathExpansion(path, out_value);
794
795 const std::string subdict_path = path.substr(0, delimiter_position);
796 DictionaryValue* subdict = NULL;
797 if (!GetDictionary(subdict_path, &subdict))
798 return false;
799 result = subdict->RemovePath(path.substr(delimiter_position + 1),
800 out_value);
801 if (result && subdict->empty())
802 RemoveWithoutPathExpansion(subdict_path, NULL);
803
804 return result;
805 }
806
DeepCopyWithoutEmptyChildren() const807 scoped_ptr<DictionaryValue> DictionaryValue::DeepCopyWithoutEmptyChildren()
808 const {
809 scoped_ptr<DictionaryValue> copy = CopyDictionaryWithoutEmptyChildren(*this);
810 if (!copy)
811 copy.reset(new DictionaryValue);
812 return copy;
813 }
814
MergeDictionary(const DictionaryValue * dictionary)815 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
816 for (DictionaryValue::Iterator it(*dictionary); !it.IsAtEnd(); it.Advance()) {
817 const Value* merge_value = &it.value();
818 // Check whether we have to merge dictionaries.
819 if (merge_value->IsType(Value::TYPE_DICTIONARY)) {
820 DictionaryValue* sub_dict;
821 if (GetDictionaryWithoutPathExpansion(it.key(), &sub_dict)) {
822 sub_dict->MergeDictionary(
823 static_cast<const DictionaryValue*>(merge_value));
824 continue;
825 }
826 }
827 // All other cases: Make a copy and hook it up.
828 SetWithoutPathExpansion(it.key(), merge_value->DeepCopy());
829 }
830 }
831
Swap(DictionaryValue * other)832 void DictionaryValue::Swap(DictionaryValue* other) {
833 dictionary_.swap(other->dictionary_);
834 }
835
Iterator(const DictionaryValue & target)836 DictionaryValue::Iterator::Iterator(const DictionaryValue& target)
837 : target_(target),
838 it_(target.dictionary_.begin()) {}
839
~Iterator()840 DictionaryValue::Iterator::~Iterator() {}
841
DeepCopy() const842 DictionaryValue* DictionaryValue::DeepCopy() const {
843 DictionaryValue* result = new DictionaryValue;
844
845 for (ValueMap::const_iterator current_entry(dictionary_.begin());
846 current_entry != dictionary_.end(); ++current_entry) {
847 result->SetWithoutPathExpansion(current_entry->first,
848 current_entry->second->DeepCopy());
849 }
850
851 return result;
852 }
853
CreateDeepCopy() const854 scoped_ptr<DictionaryValue> DictionaryValue::CreateDeepCopy() const {
855 return make_scoped_ptr(DeepCopy());
856 }
857
Equals(const Value * other) const858 bool DictionaryValue::Equals(const Value* other) const {
859 if (other->GetType() != GetType())
860 return false;
861
862 const DictionaryValue* other_dict =
863 static_cast<const DictionaryValue*>(other);
864 Iterator lhs_it(*this);
865 Iterator rhs_it(*other_dict);
866 while (!lhs_it.IsAtEnd() && !rhs_it.IsAtEnd()) {
867 if (lhs_it.key() != rhs_it.key() ||
868 !lhs_it.value().Equals(&rhs_it.value())) {
869 return false;
870 }
871 lhs_it.Advance();
872 rhs_it.Advance();
873 }
874 if (!lhs_it.IsAtEnd() || !rhs_it.IsAtEnd())
875 return false;
876
877 return true;
878 }
879
880 ///////////////////// ListValue ////////////////////
881
882 // static
From(scoped_ptr<Value> value)883 scoped_ptr<ListValue> ListValue::From(scoped_ptr<Value> value) {
884 ListValue* out;
885 if (value && value->GetAsList(&out)) {
886 ignore_result(value.release());
887 return make_scoped_ptr(out);
888 }
889 return nullptr;
890 }
891
ListValue()892 ListValue::ListValue() : Value(TYPE_LIST) {
893 }
894
~ListValue()895 ListValue::~ListValue() {
896 Clear();
897 }
898
Clear()899 void ListValue::Clear() {
900 for (ValueVector::iterator i(list_.begin()); i != list_.end(); ++i)
901 delete *i;
902 list_.clear();
903 }
904
Set(size_t index,Value * in_value)905 bool ListValue::Set(size_t index, Value* in_value) {
906 if (!in_value)
907 return false;
908
909 if (index >= list_.size()) {
910 // Pad out any intermediate indexes with null settings
911 while (index > list_.size())
912 Append(CreateNullValue());
913 Append(in_value);
914 } else {
915 DCHECK(list_[index] != in_value);
916 delete list_[index];
917 list_[index] = in_value;
918 }
919 return true;
920 }
921
Set(size_t index,scoped_ptr<Value> in_value)922 bool ListValue::Set(size_t index, scoped_ptr<Value> in_value) {
923 return Set(index, in_value.release());
924 }
925
Get(size_t index,const Value ** out_value) const926 bool ListValue::Get(size_t index, const Value** out_value) const {
927 if (index >= list_.size())
928 return false;
929
930 if (out_value)
931 *out_value = list_[index];
932
933 return true;
934 }
935
Get(size_t index,Value ** out_value)936 bool ListValue::Get(size_t index, Value** out_value) {
937 return static_cast<const ListValue&>(*this).Get(
938 index,
939 const_cast<const Value**>(out_value));
940 }
941
GetBoolean(size_t index,bool * bool_value) const942 bool ListValue::GetBoolean(size_t index, bool* bool_value) const {
943 const Value* value;
944 if (!Get(index, &value))
945 return false;
946
947 return value->GetAsBoolean(bool_value);
948 }
949
GetInteger(size_t index,int * out_value) const950 bool ListValue::GetInteger(size_t index, int* out_value) const {
951 const Value* value;
952 if (!Get(index, &value))
953 return false;
954
955 return value->GetAsInteger(out_value);
956 }
957
GetDouble(size_t index,double * out_value) const958 bool ListValue::GetDouble(size_t index, double* out_value) const {
959 const Value* value;
960 if (!Get(index, &value))
961 return false;
962
963 return value->GetAsDouble(out_value);
964 }
965
GetString(size_t index,std::string * out_value) const966 bool ListValue::GetString(size_t index, std::string* out_value) const {
967 const Value* value;
968 if (!Get(index, &value))
969 return false;
970
971 return value->GetAsString(out_value);
972 }
973
GetString(size_t index,string16 * out_value) const974 bool ListValue::GetString(size_t index, string16* out_value) const {
975 const Value* value;
976 if (!Get(index, &value))
977 return false;
978
979 return value->GetAsString(out_value);
980 }
981
GetBinary(size_t index,const BinaryValue ** out_value) const982 bool ListValue::GetBinary(size_t index, const BinaryValue** out_value) const {
983 const Value* value;
984 bool result = Get(index, &value);
985 if (!result || !value->IsType(TYPE_BINARY))
986 return false;
987
988 if (out_value)
989 *out_value = static_cast<const BinaryValue*>(value);
990
991 return true;
992 }
993
GetBinary(size_t index,BinaryValue ** out_value)994 bool ListValue::GetBinary(size_t index, BinaryValue** out_value) {
995 return static_cast<const ListValue&>(*this).GetBinary(
996 index,
997 const_cast<const BinaryValue**>(out_value));
998 }
999
GetDictionary(size_t index,const DictionaryValue ** out_value) const1000 bool ListValue::GetDictionary(size_t index,
1001 const DictionaryValue** out_value) const {
1002 const Value* value;
1003 bool result = Get(index, &value);
1004 if (!result || !value->IsType(TYPE_DICTIONARY))
1005 return false;
1006
1007 if (out_value)
1008 *out_value = static_cast<const DictionaryValue*>(value);
1009
1010 return true;
1011 }
1012
GetDictionary(size_t index,DictionaryValue ** out_value)1013 bool ListValue::GetDictionary(size_t index, DictionaryValue** out_value) {
1014 return static_cast<const ListValue&>(*this).GetDictionary(
1015 index,
1016 const_cast<const DictionaryValue**>(out_value));
1017 }
1018
GetList(size_t index,const ListValue ** out_value) const1019 bool ListValue::GetList(size_t index, const ListValue** out_value) const {
1020 const Value* value;
1021 bool result = Get(index, &value);
1022 if (!result || !value->IsType(TYPE_LIST))
1023 return false;
1024
1025 if (out_value)
1026 *out_value = static_cast<const ListValue*>(value);
1027
1028 return true;
1029 }
1030
GetList(size_t index,ListValue ** out_value)1031 bool ListValue::GetList(size_t index, ListValue** out_value) {
1032 return static_cast<const ListValue&>(*this).GetList(
1033 index,
1034 const_cast<const ListValue**>(out_value));
1035 }
1036
Remove(size_t index,scoped_ptr<Value> * out_value)1037 bool ListValue::Remove(size_t index, scoped_ptr<Value>* out_value) {
1038 if (index >= list_.size())
1039 return false;
1040
1041 if (out_value)
1042 out_value->reset(list_[index]);
1043 else
1044 delete list_[index];
1045
1046 list_.erase(list_.begin() + index);
1047 return true;
1048 }
1049
Remove(const Value & value,size_t * index)1050 bool ListValue::Remove(const Value& value, size_t* index) {
1051 for (ValueVector::iterator i(list_.begin()); i != list_.end(); ++i) {
1052 if ((*i)->Equals(&value)) {
1053 size_t previous_index = i - list_.begin();
1054 delete *i;
1055 list_.erase(i);
1056
1057 if (index)
1058 *index = previous_index;
1059 return true;
1060 }
1061 }
1062 return false;
1063 }
1064
Erase(iterator iter,scoped_ptr<Value> * out_value)1065 ListValue::iterator ListValue::Erase(iterator iter,
1066 scoped_ptr<Value>* out_value) {
1067 if (out_value)
1068 out_value->reset(*iter);
1069 else
1070 delete *iter;
1071
1072 return list_.erase(iter);
1073 }
1074
Append(scoped_ptr<Value> in_value)1075 void ListValue::Append(scoped_ptr<Value> in_value) {
1076 Append(in_value.release());
1077 }
1078
Append(Value * in_value)1079 void ListValue::Append(Value* in_value) {
1080 DCHECK(in_value);
1081 list_.push_back(in_value);
1082 }
1083
AppendBoolean(bool in_value)1084 void ListValue::AppendBoolean(bool in_value) {
1085 Append(new FundamentalValue(in_value));
1086 }
1087
AppendInteger(int in_value)1088 void ListValue::AppendInteger(int in_value) {
1089 Append(new FundamentalValue(in_value));
1090 }
1091
AppendDouble(double in_value)1092 void ListValue::AppendDouble(double in_value) {
1093 Append(new FundamentalValue(in_value));
1094 }
1095
AppendString(const std::string & in_value)1096 void ListValue::AppendString(const std::string& in_value) {
1097 Append(new StringValue(in_value));
1098 }
1099
AppendString(const string16 & in_value)1100 void ListValue::AppendString(const string16& in_value) {
1101 Append(new StringValue(in_value));
1102 }
1103
AppendStrings(const std::vector<std::string> & in_values)1104 void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
1105 for (std::vector<std::string>::const_iterator it = in_values.begin();
1106 it != in_values.end(); ++it) {
1107 AppendString(*it);
1108 }
1109 }
1110
AppendStrings(const std::vector<string16> & in_values)1111 void ListValue::AppendStrings(const std::vector<string16>& in_values) {
1112 for (std::vector<string16>::const_iterator it = in_values.begin();
1113 it != in_values.end(); ++it) {
1114 AppendString(*it);
1115 }
1116 }
1117
AppendIfNotPresent(Value * in_value)1118 bool ListValue::AppendIfNotPresent(Value* in_value) {
1119 DCHECK(in_value);
1120 for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i) {
1121 if ((*i)->Equals(in_value)) {
1122 delete in_value;
1123 return false;
1124 }
1125 }
1126 list_.push_back(in_value);
1127 return true;
1128 }
1129
Insert(size_t index,Value * in_value)1130 bool ListValue::Insert(size_t index, Value* in_value) {
1131 DCHECK(in_value);
1132 if (index > list_.size())
1133 return false;
1134
1135 list_.insert(list_.begin() + index, in_value);
1136 return true;
1137 }
1138
Find(const Value & value) const1139 ListValue::const_iterator ListValue::Find(const Value& value) const {
1140 return std::find_if(list_.begin(), list_.end(), ValueEquals(&value));
1141 }
1142
Swap(ListValue * other)1143 void ListValue::Swap(ListValue* other) {
1144 list_.swap(other->list_);
1145 }
1146
GetAsList(ListValue ** out_value)1147 bool ListValue::GetAsList(ListValue** out_value) {
1148 if (out_value)
1149 *out_value = this;
1150 return true;
1151 }
1152
GetAsList(const ListValue ** out_value) const1153 bool ListValue::GetAsList(const ListValue** out_value) const {
1154 if (out_value)
1155 *out_value = this;
1156 return true;
1157 }
1158
DeepCopy() const1159 ListValue* ListValue::DeepCopy() const {
1160 ListValue* result = new ListValue;
1161
1162 for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i)
1163 result->Append((*i)->DeepCopy());
1164
1165 return result;
1166 }
1167
CreateDeepCopy() const1168 scoped_ptr<ListValue> ListValue::CreateDeepCopy() const {
1169 return make_scoped_ptr(DeepCopy());
1170 }
1171
Equals(const Value * other) const1172 bool ListValue::Equals(const Value* other) const {
1173 if (other->GetType() != GetType())
1174 return false;
1175
1176 const ListValue* other_list =
1177 static_cast<const ListValue*>(other);
1178 const_iterator lhs_it, rhs_it;
1179 for (lhs_it = begin(), rhs_it = other_list->begin();
1180 lhs_it != end() && rhs_it != other_list->end();
1181 ++lhs_it, ++rhs_it) {
1182 if (!(*lhs_it)->Equals(*rhs_it))
1183 return false;
1184 }
1185 if (lhs_it != end() || rhs_it != other_list->end())
1186 return false;
1187
1188 return true;
1189 }
1190
~ValueSerializer()1191 ValueSerializer::~ValueSerializer() {
1192 }
1193
~ValueDeserializer()1194 ValueDeserializer::~ValueDeserializer() {
1195 }
1196
operator <<(std::ostream & out,const Value & value)1197 std::ostream& operator<<(std::ostream& out, const Value& value) {
1198 std::string json;
1199 JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
1200 return out << json;
1201 }
1202
1203 } // namespace base
1204