OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "extensions/common/message_bundle.h" | 5 #include "extensions/common/message_bundle.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <string> | 10 #include <string> |
| 11 #include <utility> |
11 #include <vector> | 12 #include <vector> |
12 | 13 |
13 #include "base/i18n/rtl.h" | 14 #include "base/i18n/rtl.h" |
14 #include "base/macros.h" | 15 #include "base/macros.h" |
| 16 #include "base/memory/ptr_util.h" |
15 #include "base/strings/string_util.h" | 17 #include "base/strings/string_util.h" |
16 #include "base/strings/utf_string_conversions.h" | 18 #include "base/strings/utf_string_conversions.h" |
17 #include "base/values.h" | 19 #include "base/values.h" |
18 #include "extensions/common/error_utils.h" | 20 #include "extensions/common/error_utils.h" |
19 #include "extensions/common/extension_l10n_util.h" | 21 #include "extensions/common/extension_l10n_util.h" |
20 #include "extensions/common/manifest_constants.h" | 22 #include "extensions/common/manifest_constants.h" |
21 #include "testing/gtest/include/gtest/gtest.h" | 23 #include "testing/gtest/include/gtest/gtest.h" |
22 | 24 |
23 namespace extensions { | 25 namespace extensions { |
24 | 26 |
25 namespace errors = manifest_errors; | 27 namespace errors = manifest_errors; |
26 | 28 |
27 class MessageBundleTest : public testing::Test { | 29 class MessageBundleTest : public testing::Test { |
28 protected: | 30 protected: |
29 enum BadDictionary { | 31 enum BadDictionary { |
30 INVALID_NAME, | 32 INVALID_NAME, |
31 NAME_NOT_A_TREE, | 33 NAME_NOT_A_TREE, |
32 EMPTY_NAME_TREE, | 34 EMPTY_NAME_TREE, |
33 MISSING_MESSAGE, | 35 MISSING_MESSAGE, |
34 PLACEHOLDER_NOT_A_TREE, | 36 PLACEHOLDER_NOT_A_TREE, |
35 EMPTY_PLACEHOLDER_TREE, | 37 EMPTY_PLACEHOLDER_TREE, |
36 CONTENT_MISSING, | 38 CONTENT_MISSING, |
37 MESSAGE_PLACEHOLDER_DOESNT_MATCH, | 39 MESSAGE_PLACEHOLDER_DOESNT_MATCH, |
38 }; | 40 }; |
39 | 41 |
40 // Helper method for dictionary building. | |
41 void SetDictionary(const std::string& name, | |
42 base::DictionaryValue* subtree, | |
43 base::DictionaryValue* target) { | |
44 target->Set(name, static_cast<base::Value*>(subtree)); | |
45 } | |
46 | |
47 void CreateContentTree(const std::string& name, | 42 void CreateContentTree(const std::string& name, |
48 const std::string& content, | 43 const std::string& content, |
49 base::DictionaryValue* dict) { | 44 base::DictionaryValue* dict) { |
50 base::DictionaryValue* content_tree = new base::DictionaryValue; | 45 auto content_tree = base::MakeUnique<base::DictionaryValue>(); |
51 content_tree->SetString(MessageBundle::kContentKey, content); | 46 content_tree->SetString(MessageBundle::kContentKey, content); |
52 SetDictionary(name, content_tree, dict); | 47 dict->Set(name, std::move(content_tree)); |
53 } | 48 } |
54 | 49 |
55 void CreatePlaceholdersTree(base::DictionaryValue* dict) { | 50 void CreatePlaceholdersTree(base::DictionaryValue* dict) { |
56 base::DictionaryValue* placeholders_tree = new base::DictionaryValue; | 51 auto placeholders_tree = base::MakeUnique<base::DictionaryValue>(); |
57 CreateContentTree("a", "A", placeholders_tree); | 52 CreateContentTree("a", "A", placeholders_tree.get()); |
58 CreateContentTree("b", "B", placeholders_tree); | 53 CreateContentTree("b", "B", placeholders_tree.get()); |
59 CreateContentTree("c", "C", placeholders_tree); | 54 CreateContentTree("c", "C", placeholders_tree.get()); |
60 SetDictionary(MessageBundle::kPlaceholdersKey, | 55 dict->Set(MessageBundle::kPlaceholdersKey, std::move(placeholders_tree)); |
61 placeholders_tree, | |
62 dict); | |
63 } | 56 } |
64 | 57 |
65 void CreateMessageTree(const std::string& name, | 58 void CreateMessageTree(const std::string& name, |
66 const std::string& message, | 59 const std::string& message, |
67 bool create_placeholder_subtree, | 60 bool create_placeholder_subtree, |
68 base::DictionaryValue* dict) { | 61 base::DictionaryValue* dict) { |
69 base::DictionaryValue* message_tree = new base::DictionaryValue; | 62 auto message_tree = base::MakeUnique<base::DictionaryValue>(); |
70 if (create_placeholder_subtree) | 63 if (create_placeholder_subtree) |
71 CreatePlaceholdersTree(message_tree); | 64 CreatePlaceholdersTree(message_tree.get()); |
72 message_tree->SetString(MessageBundle::kMessageKey, message); | 65 message_tree->SetString(MessageBundle::kMessageKey, message); |
73 SetDictionary(name, message_tree, dict); | 66 dict->Set(name, std::move(message_tree)); |
74 } | 67 } |
75 | 68 |
76 std::unique_ptr<base::DictionaryValue> CreateGoodDictionary() { | 69 std::unique_ptr<base::DictionaryValue> CreateGoodDictionary() { |
77 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue()); | 70 auto dict = base::MakeUnique<base::DictionaryValue>(); |
78 CreateMessageTree("n1", "message1 $a$ $b$", true, dict.get()); | 71 CreateMessageTree("n1", "message1 $a$ $b$", true, dict.get()); |
79 CreateMessageTree("n2", "message2 $c$", true, dict.get()); | 72 CreateMessageTree("n2", "message2 $c$", true, dict.get()); |
80 CreateMessageTree("n3", "message3", false, dict.get()); | 73 CreateMessageTree("n3", "message3", false, dict.get()); |
81 return dict; | 74 return dict; |
82 } | 75 } |
83 | 76 |
84 std::unique_ptr<base::DictionaryValue> CreateBadDictionary( | 77 std::unique_ptr<base::DictionaryValue> CreateBadDictionary( |
85 enum BadDictionary what_is_bad) { | 78 enum BadDictionary what_is_bad) { |
86 std::unique_ptr<base::DictionaryValue> dict = CreateGoodDictionary(); | 79 std::unique_ptr<base::DictionaryValue> dict = CreateGoodDictionary(); |
87 // Now remove/break things. | 80 // Now remove/break things. |
88 switch (what_is_bad) { | 81 switch (what_is_bad) { |
89 case INVALID_NAME: | 82 case INVALID_NAME: |
90 CreateMessageTree("n 5", "nevermind", false, dict.get()); | 83 CreateMessageTree("n 5", "nevermind", false, dict.get()); |
91 break; | 84 break; |
92 case NAME_NOT_A_TREE: | 85 case NAME_NOT_A_TREE: |
93 dict->SetString("n4", "whatever"); | 86 dict->SetString("n4", "whatever"); |
94 break; | 87 break; |
95 case EMPTY_NAME_TREE: { | 88 case EMPTY_NAME_TREE: |
96 base::DictionaryValue* empty_tree = new base::DictionaryValue; | 89 dict->Set("n4", base::MakeUnique<base::DictionaryValue>()); |
97 SetDictionary("n4", empty_tree, dict.get()); | |
98 } | |
99 break; | 90 break; |
100 case MISSING_MESSAGE: | 91 case MISSING_MESSAGE: |
101 dict->Remove("n1.message", NULL); | 92 dict->Remove("n1.message", NULL); |
102 break; | 93 break; |
103 case PLACEHOLDER_NOT_A_TREE: | 94 case PLACEHOLDER_NOT_A_TREE: |
104 dict->SetString("n1.placeholders", "whatever"); | 95 dict->SetString("n1.placeholders", "whatever"); |
105 break; | 96 break; |
106 case EMPTY_PLACEHOLDER_TREE: { | 97 case EMPTY_PLACEHOLDER_TREE: |
107 base::DictionaryValue* empty_tree = new base::DictionaryValue; | 98 dict->Set("n1.placeholders", base::MakeUnique<base::DictionaryValue>()); |
108 SetDictionary("n1.placeholders", empty_tree, dict.get()); | |
109 } | |
110 break; | 99 break; |
111 case CONTENT_MISSING: | 100 case CONTENT_MISSING: |
112 dict->Remove("n1.placeholders.a.content", NULL); | 101 dict->Remove("n1.placeholders.a.content", NULL); |
113 break; | 102 break; |
114 case MESSAGE_PLACEHOLDER_DOESNT_MATCH: | 103 case MESSAGE_PLACEHOLDER_DOESNT_MATCH: |
115 base::DictionaryValue* value; | 104 base::DictionaryValue* value; |
116 dict->Remove("n1.placeholders.a", NULL); | 105 dict->Remove("n1.placeholders.a", NULL); |
117 dict->GetDictionary("n1.placeholders", &value); | 106 dict->GetDictionary("n1.placeholders", &value); |
118 CreateContentTree("x", "X", value); | 107 CreateContentTree("x", "X", value); |
119 break; | 108 break; |
(...skipping 300 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
420 messages.insert(std::make_pair("message_name", "message_value")); | 409 messages.insert(std::make_pair("message_name", "message_value")); |
421 (*GetExtensionToL10nMessagesMap())[extension_id] = messages; | 410 (*GetExtensionToL10nMessagesMap())[extension_id] = messages; |
422 | 411 |
423 L10nMessagesMap* map = GetL10nMessagesMap(extension_id); | 412 L10nMessagesMap* map = GetL10nMessagesMap(extension_id); |
424 ASSERT_TRUE(NULL != map); | 413 ASSERT_TRUE(NULL != map); |
425 EXPECT_EQ(1U, map->size()); | 414 EXPECT_EQ(1U, map->size()); |
426 EXPECT_EQ("message_value", (*map)["message_name"]); | 415 EXPECT_EQ("message_value", (*map)["message_name"]); |
427 } | 416 } |
428 | 417 |
429 } // namespace extensions | 418 } // namespace extensions |
OLD | NEW |