| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2008-2009 Google Inc. | |
| 2 // | |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
| 4 // you may not use this file except in compliance with the License. | |
| 5 // You may obtain a copy of the License at | |
| 6 // | |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 // | |
| 9 // Unless required by applicable law or agreed to in writing, software | |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, | |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 12 // See the License for the specific language governing permissions and | |
| 13 // limitations under the License. | |
| 14 // ======================================================================== | |
| 15 | |
| 16 #include "omaha/base/browser_utils.h" | |
| 17 #include "omaha/base/const_utils.h" | |
| 18 #include "omaha/base/path.h" | |
| 19 #include "omaha/base/reg_key.h" | |
| 20 #include "omaha/base/utils.h" | |
| 21 #include "omaha/testing/unit_test.h" | |
| 22 | |
| 23 namespace omaha { | |
| 24 | |
| 25 const CString kRegistryHiveOverrideClasses = | |
| 26 CString(kRegistryHiveOverrideRoot) + _T("HKCR"); | |
| 27 | |
| 28 // GetDefaultBrowserName() uses ::RegOpenCurrentUser, which does not appear to | |
| 29 // be affected by registry hive overrides. Therefore, in order to test methods | |
| 30 // that rely on it, the actual value must be replaced. This class saves the | |
| 31 // value and restores it. If the test is interrupted before TearDown, the | |
| 32 // default browser may not be correctly registered. | |
| 33 class BrowserUtilsDefaultBrowserSavedTest : public testing::Test { | |
| 34 protected: | |
| 35 virtual void SetUp() { | |
| 36 if (!RegKey::HasKey(kRegKeyUserDefaultBrowser)) { | |
| 37 return; | |
| 38 } | |
| 39 | |
| 40 EXPECT_SUCCEEDED(RegKey::GetValue(kRegKeyUserDefaultBrowser, | |
| 41 NULL, | |
| 42 &default_browser_name_)); | |
| 43 } | |
| 44 | |
| 45 virtual void TearDown() { | |
| 46 if (default_browser_name_.IsEmpty()) { | |
| 47 RegKey::DeleteKey(kRegKeyUserDefaultBrowser); | |
| 48 return; | |
| 49 } | |
| 50 | |
| 51 EXPECT_SUCCEEDED(RegKey::SetValue(kRegKeyUserDefaultBrowser, | |
| 52 NULL, | |
| 53 default_browser_name_)); | |
| 54 } | |
| 55 | |
| 56 CString default_browser_name_; | |
| 57 }; | |
| 58 | |
| 59 class GetLegacyDefaultBrowserInfoTest : public testing::Test { | |
| 60 protected: | |
| 61 virtual void SetUp() { | |
| 62 RegKey::DeleteKey(kRegistryHiveOverrideClasses, true); | |
| 63 RegKey classes_key; | |
| 64 ASSERT_HRESULT_SUCCEEDED(classes_key.Create(kRegistryHiveOverrideClasses)); | |
| 65 ASSERT_HRESULT_SUCCEEDED(::RegOverridePredefKey(HKEY_CLASSES_ROOT, | |
| 66 classes_key.Key())); | |
| 67 } | |
| 68 | |
| 69 virtual void TearDown() { | |
| 70 ASSERT_HRESULT_SUCCEEDED(::RegOverridePredefKey(HKEY_CLASSES_ROOT, NULL)); | |
| 71 ASSERT_HRESULT_SUCCEEDED(RegKey::DeleteKey(kRegistryHiveOverrideClasses, | |
| 72 true)); | |
| 73 } | |
| 74 }; | |
| 75 | |
| 76 TEST_F(BrowserUtilsDefaultBrowserSavedTest, GetDefaultBrowserType_IE) { | |
| 77 if (!ShouldRunLargeTest()) { | |
| 78 return; | |
| 79 } | |
| 80 EXPECT_SUCCEEDED( | |
| 81 RegKey::SetValue(kRegKeyUserDefaultBrowser, NULL, _T("IeXpLoRe.ExE"))); | |
| 82 BrowserType type = BROWSER_UNKNOWN; | |
| 83 EXPECT_SUCCEEDED(GetDefaultBrowserType(&type)); | |
| 84 EXPECT_EQ(BROWSER_IE, type); | |
| 85 } | |
| 86 | |
| 87 TEST_F(BrowserUtilsDefaultBrowserSavedTest, GetDefaultBrowserType_Firefox) { | |
| 88 if (!ShouldRunLargeTest()) { | |
| 89 return; | |
| 90 } | |
| 91 EXPECT_SUCCEEDED( | |
| 92 RegKey::SetValue(kRegKeyUserDefaultBrowser, NULL, _T("FiReFoX.ExE"))); | |
| 93 BrowserType type = BROWSER_UNKNOWN; | |
| 94 EXPECT_SUCCEEDED(GetDefaultBrowserType(&type)); | |
| 95 EXPECT_EQ(BROWSER_FIREFOX, type); | |
| 96 } | |
| 97 | |
| 98 TEST_F(BrowserUtilsDefaultBrowserSavedTest, GetDefaultBrowserType_Chrome) { | |
| 99 if (!ShouldRunLargeTest()) { | |
| 100 return; | |
| 101 } | |
| 102 EXPECT_SUCCEEDED( | |
| 103 RegKey::SetValue(kRegKeyUserDefaultBrowser, NULL, _T("ChRoMe.ExE"))); | |
| 104 BrowserType type = BROWSER_UNKNOWN; | |
| 105 EXPECT_SUCCEEDED(GetDefaultBrowserType(&type)); | |
| 106 EXPECT_EQ(BROWSER_CHROME, type); | |
| 107 } | |
| 108 | |
| 109 TEST_F(BrowserUtilsDefaultBrowserSavedTest, GetDefaultBrowserType_Unsupported) { | |
| 110 if (!ShouldRunLargeTest()) { | |
| 111 return; | |
| 112 } | |
| 113 EXPECT_SUCCEEDED( | |
| 114 RegKey::SetValue(kRegKeyUserDefaultBrowser, NULL, _T("FoO.ExE"))); | |
| 115 BrowserType type = BROWSER_UNKNOWN; | |
| 116 EXPECT_SUCCEEDED(GetDefaultBrowserType(&type)); | |
| 117 EXPECT_EQ(BROWSER_UNKNOWN, type); | |
| 118 } | |
| 119 | |
| 120 TEST(BrowserUtilsTest, BrowserTypeToProcessName_Unknown) { | |
| 121 CString exe_name; | |
| 122 EXPECT_EQ(E_FAIL, BrowserTypeToProcessName(BROWSER_UNKNOWN, &exe_name)); | |
| 123 EXPECT_TRUE(exe_name.IsEmpty()); | |
| 124 } | |
| 125 | |
| 126 // Writes the default browser to ensure consistent results. | |
| 127 TEST_F(BrowserUtilsDefaultBrowserSavedTest, BrowserTypeToProcessName_Default) { | |
| 128 if (!ShouldRunLargeTest()) { | |
| 129 return; | |
| 130 } | |
| 131 EXPECT_SUCCEEDED( | |
| 132 RegKey::SetValue(kRegKeyUserDefaultBrowser, NULL, _T("IeXpLoRe.ExE"))); | |
| 133 | |
| 134 CString default_exe_name; | |
| 135 EXPECT_SUCCEEDED(GetDefaultBrowserName(&default_exe_name)); | |
| 136 EXPECT_STREQ(_T("IeXpLoRe.ExE"), default_exe_name); | |
| 137 | |
| 138 CString exe_name; | |
| 139 EXPECT_SUCCEEDED(BrowserTypeToProcessName(BROWSER_DEFAULT, &exe_name)); | |
| 140 EXPECT_STREQ(_T("IeXpLoRe.ExE"), exe_name); | |
| 141 } | |
| 142 | |
| 143 TEST(BrowserUtilsTest, BrowserTypeToProcessName_Browsers) { | |
| 144 CString exe_name; | |
| 145 EXPECT_SUCCEEDED(BrowserTypeToProcessName(BROWSER_IE, &exe_name)); | |
| 146 EXPECT_STREQ(_T("IEXPLORE.EXE"), exe_name); | |
| 147 EXPECT_SUCCEEDED(BrowserTypeToProcessName(BROWSER_FIREFOX, &exe_name)); | |
| 148 EXPECT_STREQ(_T("FIREFOX.EXE"), exe_name); | |
| 149 EXPECT_SUCCEEDED(BrowserTypeToProcessName(BROWSER_CHROME, &exe_name)); | |
| 150 EXPECT_STREQ(_T("CHROME.EXE"), exe_name); | |
| 151 } | |
| 152 | |
| 153 TEST(BrowserUtilsTest, BrowserTypeToProcessName_Invalid) { | |
| 154 CString exe_name; | |
| 155 ExpectAsserts expect_asserts; | |
| 156 EXPECT_EQ(E_FAIL, BrowserTypeToProcessName(BROWSER_MAX, &exe_name)); | |
| 157 EXPECT_TRUE(exe_name.IsEmpty()); | |
| 158 EXPECT_EQ(E_FAIL, | |
| 159 BrowserTypeToProcessName(static_cast<BrowserType>(9), &exe_name)); | |
| 160 EXPECT_TRUE(exe_name.IsEmpty()); | |
| 161 EXPECT_EQ(E_FAIL, | |
| 162 BrowserTypeToProcessName(static_cast<BrowserType>(-1), &exe_name)); | |
| 163 EXPECT_TRUE(exe_name.IsEmpty()); | |
| 164 } | |
| 165 | |
| 166 TEST(BrowserUtilsTest, GetBrowserImagePath_DefaultBrowser) { | |
| 167 CString browser; | |
| 168 ASSERT_SUCCEEDED(GetDefaultBrowserName(&browser)); | |
| 169 | |
| 170 BrowserType default_type = BROWSER_UNKNOWN; | |
| 171 if (browser.CompareNoCase(kIeExeName) == 0) { | |
| 172 default_type = BROWSER_IE; | |
| 173 } else if (browser.CompareNoCase(kFirefoxExeName) == 0) { | |
| 174 default_type = BROWSER_FIREFOX; | |
| 175 } else if (browser.CompareNoCase(kChromeExeName) == 0) { | |
| 176 default_type = BROWSER_CHROME; | |
| 177 } | |
| 178 | |
| 179 CString exp_browser_path; | |
| 180 ASSERT_SUCCEEDED(GetDefaultBrowserPath(&exp_browser_path)); | |
| 181 | |
| 182 if (default_type == BROWSER_IE) { | |
| 183 CString path; | |
| 184 ASSERT_SUCCEEDED(GetBrowserImagePath(BROWSER_IE, &path)); | |
| 185 | |
| 186 CString long_name; | |
| 187 ASSERT_SUCCEEDED(ShortPathToLongPath(path, &long_name)); | |
| 188 CString exp_long_name; | |
| 189 ASSERT_SUCCEEDED(ShortPathToLongPath(exp_browser_path, &exp_long_name)); | |
| 190 ASSERT_STREQ(exp_long_name.MakeLower(), long_name.MakeLower()); | |
| 191 } else if (default_type == BROWSER_FIREFOX) { | |
| 192 CString path; | |
| 193 ASSERT_SUCCEEDED(GetBrowserImagePath(BROWSER_FIREFOX, &path)); | |
| 194 | |
| 195 CString long_name; | |
| 196 ASSERT_SUCCEEDED(ShortPathToLongPath(path, &long_name)); | |
| 197 CString exp_long_name; | |
| 198 ASSERT_SUCCEEDED(ShortPathToLongPath(exp_browser_path, &exp_long_name)); | |
| 199 ASSERT_STREQ(exp_long_name.MakeLower(), long_name.MakeLower()); | |
| 200 } else if (default_type == BROWSER_CHROME) { | |
| 201 CString path; | |
| 202 ASSERT_SUCCEEDED(GetBrowserImagePath(BROWSER_CHROME, &path)); | |
| 203 | |
| 204 CString long_name; | |
| 205 ASSERT_SUCCEEDED(ShortPathToLongPath(path, &long_name)); | |
| 206 CString exp_long_name; | |
| 207 ASSERT_SUCCEEDED(ShortPathToLongPath(exp_browser_path, &exp_long_name)); | |
| 208 ASSERT_STREQ(exp_long_name.MakeLower(), long_name.MakeLower()); | |
| 209 } | |
| 210 | |
| 211 CString path; | |
| 212 ASSERT_SUCCEEDED(GetBrowserImagePath(BROWSER_DEFAULT, &path)); | |
| 213 CString long_name; | |
| 214 ASSERT_SUCCEEDED(ShortPathToLongPath(path, &long_name)); | |
| 215 CString exp_long_name; | |
| 216 ASSERT_SUCCEEDED(ShortPathToLongPath(exp_browser_path, &exp_long_name)); | |
| 217 ASSERT_STREQ(exp_long_name.MakeLower(), long_name.MakeLower()); | |
| 218 | |
| 219 ASSERT_FAILED(GetBrowserImagePath(BROWSER_UNKNOWN, &path)); | |
| 220 } | |
| 221 | |
| 222 // Try all browsers to get more test coverage. | |
| 223 TEST(BrowserUtilsTest, GetBrowserImagePath_AllSupportedBrowsers) { | |
| 224 if (IsTestRunByLocalSystem()) { | |
| 225 return; | |
| 226 } | |
| 227 | |
| 228 CString program_files_path; | |
| 229 EXPECT_SUCCEEDED(GetFolderPath(CSIDL_PROGRAM_FILES | CSIDL_FLAG_DONT_VERIFY, | |
| 230 &program_files_path)); | |
| 231 CString path; | |
| 232 | |
| 233 HRESULT hr = GetBrowserImagePath(BROWSER_IE, &path); | |
| 234 if (SUCCEEDED(hr)) { | |
| 235 EXPECT_EQ(0, path.CompareNoCase(program_files_path + | |
| 236 _T("\\Internet Explorer\\iexplore.exe"))) | |
| 237 << _T("Actual path: ") << path.GetString(); | |
| 238 } else { | |
| 239 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), hr); | |
| 240 } | |
| 241 | |
| 242 hr = GetBrowserImagePath(BROWSER_FIREFOX, &path); | |
| 243 if (SUCCEEDED(hr)) { | |
| 244 EXPECT_TRUE( | |
| 245 0 == path.CompareNoCase(program_files_path + | |
| 246 _T("\\Mozilla Firefox\\firefox.exe")) || | |
| 247 0 == path.CompareNoCase( | |
| 248 _T("C:\\PROGRA~1\\MOZILL~1\\FIREFOX.EXE")) || | |
| 249 0 == path.CompareNoCase(program_files_path + | |
| 250 _T("\\Minefield\\FIREFOX.EXE"))) // Trunk build. | |
| 251 << _T("Actual path: ") << path.GetString(); | |
| 252 } else { | |
| 253 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), hr); | |
| 254 } | |
| 255 | |
| 256 hr = GetBrowserImagePath(BROWSER_CHROME, &path); | |
| 257 if (SUCCEEDED(hr)) { | |
| 258 EXPECT_TRUE( | |
| 259 0 == path.CompareNoCase(program_files_path + | |
| 260 _T("\\Google\\Chrome\\Application\\chrome.exe")) || | |
| 261 0 == path.CompareNoCase( | |
| 262 GetLocalAppDataPath() + | |
| 263 _T("Google\\Chrome\\Application\\chrome.exe"))) | |
| 264 << _T("Actual path: ") << path.GetString(); | |
| 265 } else { | |
| 266 EXPECT_EQ(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), hr); | |
| 267 } | |
| 268 } | |
| 269 | |
| 270 TEST(BrowserUtilsTest, GetLegacyDefaultBrowserInfo) { | |
| 271 CString name; | |
| 272 CString browser_path; | |
| 273 EXPECT_SUCCEEDED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 274 EXPECT_FALSE(browser_path.IsEmpty()); | |
| 275 EXPECT_FALSE(name.IsEmpty()); | |
| 276 } | |
| 277 | |
| 278 TEST(BrowserUtilsTest, GetIeFontSize) { | |
| 279 uint32 font_size = 0; | |
| 280 const uint32 kMaxFontSize = 4; | |
| 281 EXPECT_TRUE(SUCCEEDED(GetIeFontSize(&font_size)) || IsTestRunByLocalSystem()); | |
| 282 EXPECT_LE(font_size, kMaxFontSize); | |
| 283 } | |
| 284 | |
| 285 TEST_F(GetLegacyDefaultBrowserInfoTest, ValidQuotedIE) { | |
| 286 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue( | |
| 287 kRegKeyLegacyDefaultBrowserCommand, | |
| 288 NULL, | |
| 289 _T("\"C:\\Program Files\\Internet Explorer\\iexplore.exe\" -nohome"))); | |
| 290 | |
| 291 CString name; | |
| 292 CString browser_path; | |
| 293 EXPECT_SUCCEEDED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 294 EXPECT_STREQ(_T("C:\\Program Files\\Internet Explorer\\iexplore.exe"), | |
| 295 browser_path); | |
| 296 EXPECT_STREQ(_T("iexplore.exe"), name); | |
| 297 } | |
| 298 | |
| 299 TEST_F(GetLegacyDefaultBrowserInfoTest, ValidUnquotedPath) { | |
| 300 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue( | |
| 301 kRegKeyLegacyDefaultBrowserCommand, | |
| 302 NULL, | |
| 303 _T("C:\\Program Files\\Internet Explorer\\iexplore.exe"))); | |
| 304 | |
| 305 CString name; | |
| 306 CString browser_path; | |
| 307 EXPECT_SUCCEEDED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 308 EXPECT_STREQ(_T("C:\\Program Files\\Internet Explorer\\iexplore.exe"), | |
| 309 browser_path); | |
| 310 EXPECT_STREQ(_T("iexplore.exe"), name); | |
| 311 } | |
| 312 | |
| 313 TEST_F(GetLegacyDefaultBrowserInfoTest, InvalidNoKey) { | |
| 314 CString name; | |
| 315 CString browser_path; | |
| 316 EXPECT_FAILED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 317 EXPECT_TRUE(browser_path.IsEmpty()); | |
| 318 EXPECT_TRUE(name.IsEmpty()); | |
| 319 } | |
| 320 | |
| 321 TEST_F(GetLegacyDefaultBrowserInfoTest, InvalidNoValue) { | |
| 322 EXPECT_HRESULT_SUCCEEDED(RegKey::CreateKey( | |
| 323 kRegKeyLegacyDefaultBrowserCommand)); | |
| 324 | |
| 325 CString name; | |
| 326 CString browser_path; | |
| 327 EXPECT_FAILED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 328 EXPECT_TRUE(browser_path.IsEmpty()); | |
| 329 EXPECT_TRUE(name.IsEmpty()); | |
| 330 } | |
| 331 | |
| 332 TEST_F(GetLegacyDefaultBrowserInfoTest, InvalidPath) { | |
| 333 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue( | |
| 334 kRegKeyLegacyDefaultBrowserCommand, | |
| 335 NULL, | |
| 336 _T("\"C:\\Program File\\iexplore.exe\" -nohome"))); | |
| 337 | |
| 338 CString name; | |
| 339 CString browser_path; | |
| 340 EXPECT_FAILED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 341 EXPECT_TRUE(browser_path.IsEmpty()); | |
| 342 EXPECT_TRUE(name.IsEmpty()); | |
| 343 } | |
| 344 | |
| 345 TEST_F(GetLegacyDefaultBrowserInfoTest, InvalidUnquotedPath) { | |
| 346 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue( | |
| 347 kRegKeyLegacyDefaultBrowserCommand, | |
| 348 NULL, | |
| 349 _T("C:\\Program Files\\Internet Explorer\\iexplore.exe -nohome"))); | |
| 350 | |
| 351 CString name; | |
| 352 CString browser_path; | |
| 353 EXPECT_FAILED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 354 EXPECT_TRUE(browser_path.IsEmpty()); | |
| 355 EXPECT_TRUE(name.IsEmpty()); | |
| 356 } | |
| 357 | |
| 358 TEST_F(GetLegacyDefaultBrowserInfoTest, InvalidUnquotedDirectory) { | |
| 359 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue( | |
| 360 kRegKeyLegacyDefaultBrowserCommand, | |
| 361 NULL, | |
| 362 _T("C:\\Program Files\\Internet Explorer\\"))); | |
| 363 | |
| 364 CString name; | |
| 365 CString browser_path; | |
| 366 EXPECT_FAILED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 367 EXPECT_TRUE(browser_path.IsEmpty()); | |
| 368 EXPECT_TRUE(name.IsEmpty()); | |
| 369 } | |
| 370 | |
| 371 TEST_F(GetLegacyDefaultBrowserInfoTest, InvalidQuotedDirectory) { | |
| 372 EXPECT_HRESULT_SUCCEEDED(RegKey::SetValue( | |
| 373 kRegKeyLegacyDefaultBrowserCommand, | |
| 374 NULL, | |
| 375 _T("\"C:\\Program Files\\Internet Explorer\\\" -nohome"))); | |
| 376 | |
| 377 CString name; | |
| 378 CString browser_path; | |
| 379 EXPECT_FAILED(GetLegacyDefaultBrowserInfo(&name, &browser_path)); | |
| 380 EXPECT_TRUE(browser_path.IsEmpty()); | |
| 381 EXPECT_TRUE(name.IsEmpty()); | |
| 382 } | |
| 383 | |
| 384 } // namespace omaha | |
| 385 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 624713003:
Keep only base/extractor.[cc|h]. (Closed)
Base URL: https://chromium.googlesource.com/external/omaha.git@master