OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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 <windows.h> | 5 #include <windows.h> |
6 | 6 |
7 #include "base/base_paths.h" | 7 #include "base/base_paths.h" |
8 #include "base/file_util.h" | 8 #include "base/file_util.h" |
9 #include "base/files/scoped_temp_dir.h" | 9 #include "base/files/scoped_temp_dir.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 ASSERT_FALSE(base::PathExists(dir_to_create)); | 62 ASSERT_FALSE(base::PathExists(dir_to_create)); |
63 | 63 |
64 work_item.reset(reinterpret_cast<WorkItem*>( | 64 work_item.reset(reinterpret_cast<WorkItem*>( |
65 WorkItem::CreateCreateDirWorkItem(dir_to_create))); | 65 WorkItem::CreateCreateDirWorkItem(dir_to_create))); |
66 work_item_list->AddWorkItem(work_item.release()); | 66 work_item_list->AddWorkItem(work_item.release()); |
67 | 67 |
68 std::wstring key_to_create(kTestRoot); | 68 std::wstring key_to_create(kTestRoot); |
69 key_to_create.push_back(base::FilePath::kSeparators[0]); | 69 key_to_create.push_back(base::FilePath::kSeparators[0]); |
70 key_to_create.append(L"ExecutionSuccess"); | 70 key_to_create.append(L"ExecutionSuccess"); |
71 | 71 |
72 work_item.reset(reinterpret_cast<WorkItem*>( | 72 work_item.reset( |
73 WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create))); | 73 reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem( |
| 74 HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default))); |
74 work_item_list->AddWorkItem(work_item.release()); | 75 work_item_list->AddWorkItem(work_item.release()); |
75 | 76 |
76 std::wstring name(kName); | 77 std::wstring name(kName); |
77 std::wstring data(kDataStr); | 78 std::wstring data(kDataStr); |
78 work_item.reset(reinterpret_cast<WorkItem*>( | 79 work_item.reset(reinterpret_cast<WorkItem*>( |
79 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, key_to_create, | 80 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
80 name, data, false))); | 81 key_to_create, |
| 82 WorkItem::kWow64Default, |
| 83 name, |
| 84 data, |
| 85 false))); |
81 work_item_list->AddWorkItem(work_item.release()); | 86 work_item_list->AddWorkItem(work_item.release()); |
82 | 87 |
83 EXPECT_TRUE(work_item_list->Do()); | 88 EXPECT_TRUE(work_item_list->Do()); |
84 | 89 |
85 // Verify all WorkItems have been executed. | 90 // Verify all WorkItems have been executed. |
86 RegKey key; | 91 RegKey key; |
87 EXPECT_EQ(ERROR_SUCCESS, | 92 EXPECT_EQ(ERROR_SUCCESS, |
88 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); | 93 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); |
89 std::wstring read_out; | 94 std::wstring read_out; |
90 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); | 95 EXPECT_EQ(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); |
(...skipping 23 matching lines...) Expand all Loading... |
114 ASSERT_FALSE(base::PathExists(dir_to_create)); | 119 ASSERT_FALSE(base::PathExists(dir_to_create)); |
115 | 120 |
116 work_item.reset(reinterpret_cast<WorkItem*>( | 121 work_item.reset(reinterpret_cast<WorkItem*>( |
117 WorkItem::CreateCreateDirWorkItem(dir_to_create))); | 122 WorkItem::CreateCreateDirWorkItem(dir_to_create))); |
118 work_item_list->AddWorkItem(work_item.release()); | 123 work_item_list->AddWorkItem(work_item.release()); |
119 | 124 |
120 std::wstring key_to_create(kTestRoot); | 125 std::wstring key_to_create(kTestRoot); |
121 key_to_create.push_back(base::FilePath::kSeparators[0]); | 126 key_to_create.push_back(base::FilePath::kSeparators[0]); |
122 key_to_create.append(L"ExecutionFail"); | 127 key_to_create.append(L"ExecutionFail"); |
123 | 128 |
124 work_item.reset(reinterpret_cast<WorkItem*>( | 129 work_item.reset( |
125 WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create))); | 130 reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem( |
| 131 HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default))); |
126 work_item_list->AddWorkItem(work_item.release()); | 132 work_item_list->AddWorkItem(work_item.release()); |
127 | 133 |
128 std::wstring not_created_key(kTestRoot); | 134 std::wstring not_created_key(kTestRoot); |
129 not_created_key.push_back(base::FilePath::kSeparators[0]); | 135 not_created_key.push_back(base::FilePath::kSeparators[0]); |
130 not_created_key.append(L"NotCreated"); | 136 not_created_key.append(L"NotCreated"); |
131 std::wstring name(kName); | 137 std::wstring name(kName); |
132 std::wstring data(kDataStr); | 138 std::wstring data(kDataStr); |
133 work_item.reset(reinterpret_cast<WorkItem*>( | 139 work_item.reset(reinterpret_cast<WorkItem*>( |
134 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, not_created_key, | 140 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
135 name, data, false))); | 141 not_created_key, |
| 142 WorkItem::kWow64Default, |
| 143 name, |
| 144 data, |
| 145 false))); |
136 work_item_list->AddWorkItem(work_item.release()); | 146 work_item_list->AddWorkItem(work_item.release()); |
137 | 147 |
138 // This one will not be executed because we will fail early. | 148 // This one will not be executed because we will fail early. |
139 work_item.reset(reinterpret_cast<WorkItem*>( | 149 work_item.reset( |
140 WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, | 150 reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem( |
141 not_created_key))); | 151 HKEY_CURRENT_USER, not_created_key, WorkItem::kWow64Default))); |
142 work_item_list->AddWorkItem(work_item.release()); | 152 work_item_list->AddWorkItem(work_item.release()); |
143 | 153 |
144 EXPECT_FALSE(work_item_list->Do()); | 154 EXPECT_FALSE(work_item_list->Do()); |
145 | 155 |
146 // Verify the first 2 WorkItems have been executed. | 156 // Verify the first 2 WorkItems have been executed. |
147 RegKey key; | 157 RegKey key; |
148 EXPECT_EQ(ERROR_SUCCESS, | 158 EXPECT_EQ(ERROR_SUCCESS, |
149 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); | 159 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); |
150 key.Close(); | 160 key.Close(); |
151 EXPECT_TRUE(base::PathExists(dir_to_create)); | 161 EXPECT_TRUE(base::PathExists(dir_to_create)); |
(...skipping 23 matching lines...) Expand all Loading... |
175 WorkItem::CreateCreateDirWorkItem(dir_to_create))); | 185 WorkItem::CreateCreateDirWorkItem(dir_to_create))); |
176 work_item_list->AddWorkItem(work_item.release()); | 186 work_item_list->AddWorkItem(work_item.release()); |
177 | 187 |
178 scoped_ptr<WorkItemList> conditional_work_item_list( | 188 scoped_ptr<WorkItemList> conditional_work_item_list( |
179 WorkItem::CreateConditionalWorkItemList( | 189 WorkItem::CreateConditionalWorkItemList( |
180 new ConditionRunIfFileExists(dir_to_create))); | 190 new ConditionRunIfFileExists(dir_to_create))); |
181 | 191 |
182 std::wstring key_to_create(kTestRoot); | 192 std::wstring key_to_create(kTestRoot); |
183 key_to_create.push_back(base::FilePath::kSeparators[0]); | 193 key_to_create.push_back(base::FilePath::kSeparators[0]); |
184 key_to_create.append(L"ExecutionSuccess"); | 194 key_to_create.append(L"ExecutionSuccess"); |
185 work_item.reset(reinterpret_cast<WorkItem*>( | 195 work_item.reset( |
186 WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create))); | 196 reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem( |
| 197 HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default))); |
187 conditional_work_item_list->AddWorkItem(work_item.release()); | 198 conditional_work_item_list->AddWorkItem(work_item.release()); |
188 | 199 |
189 std::wstring name(kName); | 200 std::wstring name(kName); |
190 std::wstring data(kDataStr); | 201 std::wstring data(kDataStr); |
191 work_item.reset(reinterpret_cast<WorkItem*>( | 202 work_item.reset(reinterpret_cast<WorkItem*>( |
192 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, key_to_create, | 203 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
193 name, data, false))); | 204 key_to_create, |
| 205 WorkItem::kWow64Default, |
| 206 name, |
| 207 data, |
| 208 false))); |
194 conditional_work_item_list->AddWorkItem(work_item.release()); | 209 conditional_work_item_list->AddWorkItem(work_item.release()); |
195 | 210 |
196 work_item_list->AddWorkItem(conditional_work_item_list.release()); | 211 work_item_list->AddWorkItem(conditional_work_item_list.release()); |
197 | 212 |
198 EXPECT_TRUE(work_item_list->Do()); | 213 EXPECT_TRUE(work_item_list->Do()); |
199 | 214 |
200 // Verify all WorkItems have been executed. | 215 // Verify all WorkItems have been executed. |
201 RegKey key; | 216 RegKey key; |
202 EXPECT_EQ(ERROR_SUCCESS, | 217 EXPECT_EQ(ERROR_SUCCESS, |
203 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); | 218 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); |
(...skipping 27 matching lines...) Expand all Loading... |
231 WorkItem::CreateCreateDirWorkItem(dir_to_create))); | 246 WorkItem::CreateCreateDirWorkItem(dir_to_create))); |
232 work_item_list->AddWorkItem(work_item.release()); | 247 work_item_list->AddWorkItem(work_item.release()); |
233 | 248 |
234 scoped_ptr<WorkItemList> conditional_work_item_list( | 249 scoped_ptr<WorkItemList> conditional_work_item_list( |
235 WorkItem::CreateConditionalWorkItemList( | 250 WorkItem::CreateConditionalWorkItemList( |
236 new ConditionRunIfFileExists(dir_to_create.AppendASCII("c")))); | 251 new ConditionRunIfFileExists(dir_to_create.AppendASCII("c")))); |
237 | 252 |
238 std::wstring key_to_create(kTestRoot); | 253 std::wstring key_to_create(kTestRoot); |
239 key_to_create.push_back(base::FilePath::kSeparators[0]); | 254 key_to_create.push_back(base::FilePath::kSeparators[0]); |
240 key_to_create.append(L"ExecutionSuccess"); | 255 key_to_create.append(L"ExecutionSuccess"); |
241 work_item.reset(reinterpret_cast<WorkItem*>( | 256 work_item.reset( |
242 WorkItem::CreateCreateRegKeyWorkItem(HKEY_CURRENT_USER, key_to_create))); | 257 reinterpret_cast<WorkItem*>(WorkItem::CreateCreateRegKeyWorkItem( |
| 258 HKEY_CURRENT_USER, key_to_create, WorkItem::kWow64Default))); |
243 conditional_work_item_list->AddWorkItem(work_item.release()); | 259 conditional_work_item_list->AddWorkItem(work_item.release()); |
244 | 260 |
245 std::wstring name(kName); | 261 std::wstring name(kName); |
246 std::wstring data(kDataStr); | 262 std::wstring data(kDataStr); |
247 work_item.reset(reinterpret_cast<WorkItem*>( | 263 work_item.reset(reinterpret_cast<WorkItem*>( |
248 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, key_to_create, | 264 WorkItem::CreateSetRegValueWorkItem(HKEY_CURRENT_USER, |
249 name, data, false))); | 265 key_to_create, |
| 266 WorkItem::kWow64Default, |
| 267 name, |
| 268 data, |
| 269 false))); |
250 conditional_work_item_list->AddWorkItem(work_item.release()); | 270 conditional_work_item_list->AddWorkItem(work_item.release()); |
251 | 271 |
252 work_item_list->AddWorkItem(conditional_work_item_list.release()); | 272 work_item_list->AddWorkItem(conditional_work_item_list.release()); |
253 | 273 |
254 EXPECT_TRUE(work_item_list->Do()); | 274 EXPECT_TRUE(work_item_list->Do()); |
255 | 275 |
256 // Verify that the WorkItems added as part of the conditional list have NOT | 276 // Verify that the WorkItems added as part of the conditional list have NOT |
257 // been executed. | 277 // been executed. |
258 RegKey key; | 278 RegKey key; |
259 EXPECT_NE(ERROR_SUCCESS, | 279 EXPECT_NE(ERROR_SUCCESS, |
260 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); | 280 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); |
261 std::wstring read_out; | 281 std::wstring read_out; |
262 EXPECT_NE(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); | 282 EXPECT_NE(ERROR_SUCCESS, key.ReadValue(name.c_str(), &read_out)); |
263 key.Close(); | 283 key.Close(); |
264 | 284 |
265 // Verify that the other work item was executed. | 285 // Verify that the other work item was executed. |
266 EXPECT_TRUE(base::PathExists(dir_to_create)); | 286 EXPECT_TRUE(base::PathExists(dir_to_create)); |
267 | 287 |
268 work_item_list->Rollback(); | 288 work_item_list->Rollback(); |
269 | 289 |
270 // Verify everything is rolled back. | 290 // Verify everything is rolled back. |
271 // The value must have been deleted first in roll back otherwise the key | 291 // The value must have been deleted first in roll back otherwise the key |
272 // can not be deleted. | 292 // can not be deleted. |
273 EXPECT_NE(ERROR_SUCCESS, | 293 EXPECT_NE(ERROR_SUCCESS, |
274 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); | 294 key.Open(HKEY_CURRENT_USER, key_to_create.c_str(), KEY_READ)); |
275 EXPECT_FALSE(base::PathExists(top_dir_to_create)); | 295 EXPECT_FALSE(base::PathExists(top_dir_to_create)); |
276 } | 296 } |
OLD | NEW |