| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <string> | |
| 6 | |
| 7 #include "content/browser/appcache/appcache_manifest_parser.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 #include "url/gurl.h" | |
| 10 | |
| 11 namespace content { | |
| 12 | |
| 13 class AppCacheManifestParserTest : public testing::Test { | |
| 14 }; | |
| 15 | |
| 16 TEST(AppCacheManifestParserTest, NoData) { | |
| 17 GURL url; | |
| 18 Manifest manifest; | |
| 19 EXPECT_FALSE(ParseManifest(url, "", 0, | |
| 20 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 21 EXPECT_FALSE(ParseManifest(url, "CACHE MANIFEST\r", 0, // Len is 0. | |
| 22 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 23 } | |
| 24 | |
| 25 TEST(AppCacheManifestParserTest, CheckSignature) { | |
| 26 GURL url; | |
| 27 Manifest manifest; | |
| 28 | |
| 29 const std::string kBadSignatures[] = { | |
| 30 "foo", | |
| 31 "CACHE MANIFEST;V2\r", // not followed by whitespace | |
| 32 "CACHE MANIFEST#bad\r", // no whitespace before comment | |
| 33 "cache manifest ", // wrong case | |
| 34 "#CACHE MANIFEST\r", // comment | |
| 35 "xCACHE MANIFEST\n", // bad first char | |
| 36 " CACHE MANIFEST\r", // begins with whitespace | |
| 37 "\xEF\xBE\xBF" "CACHE MANIFEST\r", // bad UTF-8 BOM value | |
| 38 }; | |
| 39 | |
| 40 for (size_t i = 0; i < arraysize(kBadSignatures); ++i) { | |
| 41 const std::string bad = kBadSignatures[i]; | |
| 42 EXPECT_FALSE(ParseManifest(url, bad.c_str(), bad.length(), | |
| 43 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 44 } | |
| 45 | |
| 46 const std::string kGoodSignatures[] = { | |
| 47 "CACHE MANIFEST", | |
| 48 "CACHE MANIFEST ", | |
| 49 "CACHE MANIFEST\r", | |
| 50 "CACHE MANIFEST\n", | |
| 51 "CACHE MANIFEST\r\n", | |
| 52 "CACHE MANIFEST\t# ignore me\r", | |
| 53 "CACHE MANIFEST ignore\r\n", | |
| 54 "CHROMIUM CACHE MANIFEST\r\n", | |
| 55 "\xEF\xBB\xBF" "CACHE MANIFEST \r\n", // BOM present | |
| 56 }; | |
| 57 | |
| 58 for (size_t i = 0; i < arraysize(kGoodSignatures); ++i) { | |
| 59 const std::string good = kGoodSignatures[i]; | |
| 60 EXPECT_TRUE(ParseManifest(url, good.c_str(), good.length(), | |
| 61 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 62 } | |
| 63 } | |
| 64 | |
| 65 TEST(AppCacheManifestParserTest, NoManifestUrl) { | |
| 66 Manifest manifest; | |
| 67 const std::string kData("CACHE MANIFEST\r" | |
| 68 "relative/tobase.com\r" | |
| 69 "http://absolute.com/addme.com"); | |
| 70 const GURL kUrl; | |
| 71 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 72 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 73 EXPECT_TRUE(manifest.explicit_urls.empty()); | |
| 74 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 75 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 76 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 77 } | |
| 78 | |
| 79 TEST(AppCacheManifestParserTest, ExplicitUrls) { | |
| 80 Manifest manifest; | |
| 81 const GURL kUrl("http://www.foo.com"); | |
| 82 const std::string kData("CACHE MANIFEST\r" | |
| 83 "relative/one\r" | |
| 84 "# some comment\r" | |
| 85 "http://www.foo.com/two#strip\r\n" | |
| 86 "NETWORK:\r" | |
| 87 " \t CACHE:\r" | |
| 88 "HTTP://www.diff.com/three\r" | |
| 89 "FALLBACK:\r" | |
| 90 " \t # another comment with leading whitespace\n" | |
| 91 "IGNORE:\r" | |
| 92 "http://www.foo.com/ignore\r" | |
| 93 "CACHE: \r" | |
| 94 "garbage:#!@\r" | |
| 95 "https://www.foo.com/diffscheme \t \r" | |
| 96 " \t relative/four#stripme\n\r" | |
| 97 "*\r"); | |
| 98 | |
| 99 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 100 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 101 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 102 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 103 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 104 | |
| 105 base::hash_set<std::string> urls = manifest.explicit_urls; | |
| 106 const size_t kExpected = 5; | |
| 107 ASSERT_EQ(kExpected, urls.size()); | |
| 108 EXPECT_TRUE(urls.find("http://www.foo.com/relative/one") != urls.end()); | |
| 109 EXPECT_TRUE(urls.find("http://www.foo.com/two") != urls.end()); | |
| 110 EXPECT_TRUE(urls.find("http://www.diff.com/three") != urls.end()); | |
| 111 EXPECT_TRUE(urls.find("http://www.foo.com/relative/four") != urls.end()); | |
| 112 | |
| 113 // Wildcard is treated as a relative URL in explicit section. | |
| 114 EXPECT_TRUE(urls.find("http://www.foo.com/*") != urls.end()); | |
| 115 | |
| 116 // We should get the same results with intercepts disallowed. | |
| 117 manifest = Manifest(); | |
| 118 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 119 PARSE_MANIFEST_PER_STANDARD, manifest)); | |
| 120 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 121 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 122 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 123 | |
| 124 urls = manifest.explicit_urls; | |
| 125 ASSERT_EQ(kExpected, urls.size()); | |
| 126 EXPECT_TRUE(urls.find("http://www.foo.com/relative/one") != urls.end()); | |
| 127 EXPECT_TRUE(urls.find("http://www.foo.com/two") != urls.end()); | |
| 128 EXPECT_TRUE(urls.find("http://www.diff.com/three") != urls.end()); | |
| 129 EXPECT_TRUE(urls.find("http://www.foo.com/relative/four") != urls.end()); | |
| 130 | |
| 131 // Wildcard is treated as a relative URL in explicit section. | |
| 132 EXPECT_TRUE(urls.find("http://www.foo.com/*") != urls.end()); | |
| 133 } | |
| 134 | |
| 135 TEST(AppCacheManifestParserTest, WhitelistUrls) { | |
| 136 Manifest manifest; | |
| 137 const GURL kUrl("http://www.bar.com"); | |
| 138 const std::string kData("CACHE MANIFEST\r" | |
| 139 "NETWORK:\r" | |
| 140 "relative/one\r" | |
| 141 "# a comment\r" | |
| 142 "http://www.bar.com/two\r" | |
| 143 "HTTP://www.diff.com/three#strip\n\r" | |
| 144 "FALLBACK:\r" | |
| 145 "garbage\r" | |
| 146 "UNKNOWN:\r" | |
| 147 "http://www.bar.com/ignore\r" | |
| 148 "CACHE:\r" | |
| 149 "NETWORK:\r" | |
| 150 "https://www.wrongscheme.com\n" | |
| 151 "relative/four#stripref \t \r" | |
| 152 "http://www.five.com\r\n" | |
| 153 "*foo\r"); | |
| 154 | |
| 155 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 156 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 157 EXPECT_TRUE(manifest.explicit_urls.empty()); | |
| 158 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 159 EXPECT_TRUE(manifest.intercept_namespaces.empty()); | |
| 160 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 161 | |
| 162 const AppCacheNamespaceVector& online = manifest.online_whitelist_namespaces; | |
| 163 const size_t kExpected = 6; | |
| 164 ASSERT_EQ(kExpected, online.size()); | |
| 165 EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE, online[0].type); | |
| 166 EXPECT_FALSE(online[0].is_pattern); | |
| 167 EXPECT_TRUE(online[0].target_url.is_empty()); | |
| 168 EXPECT_EQ(GURL("http://www.bar.com/relative/one"), online[0].namespace_url); | |
| 169 EXPECT_EQ(GURL("http://www.bar.com/two"), online[1].namespace_url); | |
| 170 EXPECT_EQ(GURL("http://www.diff.com/three"), online[2].namespace_url); | |
| 171 EXPECT_EQ(GURL("http://www.bar.com/relative/four"), online[3].namespace_url); | |
| 172 EXPECT_EQ(GURL("http://www.five.com"), online[4].namespace_url); | |
| 173 EXPECT_EQ(GURL("http://www.bar.com/*foo"), online[5].namespace_url); | |
| 174 } | |
| 175 | |
| 176 TEST(AppCacheManifestParserTest, FallbackUrls) { | |
| 177 Manifest manifest; | |
| 178 const GURL kUrl("http://glorp.com"); | |
| 179 const std::string kData("CACHE MANIFEST\r" | |
| 180 "# a comment\r" | |
| 181 "CACHE:\r" | |
| 182 "NETWORK:\r" | |
| 183 "UNKNOWN:\r" | |
| 184 "FALLBACK:\r" | |
| 185 "relative/one \t \t http://glorp.com/onefb \t \r" | |
| 186 "*\r" | |
| 187 "https://glorp.com/wrong http://glorp.com/wrongfb\r" | |
| 188 "http://glorp.com/two#strip relative/twofb\r" | |
| 189 "HTTP://glorp.com/three relative/threefb#strip\n" | |
| 190 "http://glorp.com/three http://glorp.com/three-dup\r" | |
| 191 "http://glorp.com/solo \t \r\n" | |
| 192 "http://diff.com/ignore http://glorp.com/wronghost\r" | |
| 193 "http://glorp.com/wronghost http://diff.com/ohwell\r" | |
| 194 "relative/badscheme ftp://glorp.com/ignored\r" | |
| 195 "garbage\r\n" | |
| 196 "CACHE:\r" | |
| 197 "# only fallback urls in this test\r" | |
| 198 "FALLBACK:\n" | |
| 199 "relative/four#strip relative/fourfb#strip\r" | |
| 200 "http://www.glorp.com/notsame relative/skipped\r"); | |
| 201 | |
| 202 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 203 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 204 EXPECT_TRUE(manifest.explicit_urls.empty()); | |
| 205 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 206 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 207 | |
| 208 const AppCacheNamespaceVector& fallbacks = manifest.fallback_namespaces; | |
| 209 const size_t kExpected = 5; | |
| 210 ASSERT_EQ(kExpected, fallbacks.size()); | |
| 211 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[0].type); | |
| 212 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[1].type); | |
| 213 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[2].type); | |
| 214 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[3].type); | |
| 215 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[4].type); | |
| 216 EXPECT_EQ(GURL("http://glorp.com/relative/one"), | |
| 217 fallbacks[0].namespace_url); | |
| 218 EXPECT_EQ(GURL("http://glorp.com/onefb"), | |
| 219 fallbacks[0].target_url); | |
| 220 EXPECT_EQ(GURL("http://glorp.com/two"), | |
| 221 fallbacks[1].namespace_url); | |
| 222 EXPECT_EQ(GURL("http://glorp.com/relative/twofb"), | |
| 223 fallbacks[1].target_url); | |
| 224 EXPECT_EQ(GURL("http://glorp.com/three"), | |
| 225 fallbacks[2].namespace_url); | |
| 226 EXPECT_EQ(GURL("http://glorp.com/relative/threefb"), | |
| 227 fallbacks[2].target_url); | |
| 228 EXPECT_EQ(GURL("http://glorp.com/three"), // duplicates are stored | |
| 229 fallbacks[3].namespace_url); | |
| 230 EXPECT_EQ(GURL("http://glorp.com/three-dup"), | |
| 231 fallbacks[3].target_url); | |
| 232 EXPECT_EQ(GURL("http://glorp.com/relative/four"), | |
| 233 fallbacks[4].namespace_url); | |
| 234 EXPECT_EQ(GURL("http://glorp.com/relative/fourfb"), | |
| 235 fallbacks[4].target_url); | |
| 236 | |
| 237 EXPECT_TRUE(manifest.intercept_namespaces.empty()); | |
| 238 } | |
| 239 | |
| 240 TEST(AppCacheManifestParserTest, FallbackUrlsWithPort) { | |
| 241 Manifest manifest; | |
| 242 const GURL kUrl("http://www.portme.com:1234"); | |
| 243 const std::string kData("CACHE MANIFEST\r" | |
| 244 "FALLBACK:\r" | |
| 245 "http://www.portme.com:1234/one relative/onefb\r" | |
| 246 "HTTP://www.portme.com:9876/wrong http://www.portme.com:1234/ignore\r" | |
| 247 "http://www.portme.com:1234/stillwrong http://www.portme.com:42/boo\r" | |
| 248 "relative/two relative/twofb\r" | |
| 249 "http://www.portme.com:1234/three HTTP://www.portme.com:1234/threefb\r" | |
| 250 "http://www.portme.com/noport http://www.portme.com:1234/skipped\r" | |
| 251 "http://www.portme.com:1234/skipme http://www.portme.com/noport\r"); | |
| 252 | |
| 253 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 254 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 255 EXPECT_TRUE(manifest.explicit_urls.empty()); | |
| 256 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 257 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 258 | |
| 259 const AppCacheNamespaceVector& fallbacks = manifest.fallback_namespaces; | |
| 260 const size_t kExpected = 3; | |
| 261 ASSERT_EQ(kExpected, fallbacks.size()); | |
| 262 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[0].type); | |
| 263 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[1].type); | |
| 264 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[2].type); | |
| 265 EXPECT_EQ(GURL("http://www.portme.com:1234/one"), | |
| 266 fallbacks[0].namespace_url); | |
| 267 EXPECT_EQ(GURL("http://www.portme.com:1234/relative/onefb"), | |
| 268 fallbacks[0].target_url); | |
| 269 EXPECT_EQ(GURL("http://www.portme.com:1234/relative/two"), | |
| 270 fallbacks[1].namespace_url); | |
| 271 EXPECT_EQ(GURL("http://www.portme.com:1234/relative/twofb"), | |
| 272 fallbacks[1].target_url); | |
| 273 EXPECT_EQ(GURL("http://www.portme.com:1234/three"), | |
| 274 fallbacks[2].namespace_url); | |
| 275 EXPECT_EQ(GURL("http://www.portme.com:1234/threefb"), | |
| 276 fallbacks[2].target_url); | |
| 277 | |
| 278 EXPECT_TRUE(manifest.intercept_namespaces.empty()); | |
| 279 } | |
| 280 | |
| 281 TEST(AppCacheManifestParserTest, InterceptUrls) { | |
| 282 Manifest manifest; | |
| 283 const GURL kUrl("http://www.portme.com:1234"); | |
| 284 const std::string kData("CHROMIUM CACHE MANIFEST\r" | |
| 285 "CHROMIUM-INTERCEPT:\r" | |
| 286 "http://www.portme.com:1234/one return relative/int1\r" | |
| 287 "HTTP://www.portme.com:9/wrong return http://www.portme.com:1234/ignore\r" | |
| 288 "http://www.portme.com:1234/wrong return http://www.portme.com:9/boo\r" | |
| 289 "relative/two return relative/int2\r" | |
| 290 "relative/three wrong relative/threefb\r" | |
| 291 "http://www.portme.com:1234/three return HTTP://www.portme.com:1234/int3\r" | |
| 292 "http://www.portme.com/noport return http://www.portme.com:1234/skipped\r" | |
| 293 "http://www.portme.com:1234/skipme return http://www.portme.com/noport\r" | |
| 294 "relative/wrong/again missing/intercept_type\r"); | |
| 295 | |
| 296 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 297 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 298 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 299 EXPECT_TRUE(manifest.explicit_urls.empty()); | |
| 300 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 301 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 302 | |
| 303 const AppCacheNamespaceVector& intercepts = manifest.intercept_namespaces; | |
| 304 const size_t kExpected = 3; | |
| 305 ASSERT_EQ(kExpected, intercepts.size()); | |
| 306 EXPECT_EQ(APPCACHE_INTERCEPT_NAMESPACE, intercepts[0].type); | |
| 307 EXPECT_EQ(APPCACHE_INTERCEPT_NAMESPACE, intercepts[1].type); | |
| 308 EXPECT_EQ(APPCACHE_INTERCEPT_NAMESPACE, intercepts[2].type); | |
| 309 EXPECT_EQ(GURL("http://www.portme.com:1234/one"), | |
| 310 intercepts[0].namespace_url); | |
| 311 EXPECT_EQ(GURL("http://www.portme.com:1234/relative/int1"), | |
| 312 intercepts[0].target_url); | |
| 313 EXPECT_EQ(GURL("http://www.portme.com:1234/relative/two"), | |
| 314 intercepts[1].namespace_url); | |
| 315 EXPECT_EQ(GURL("http://www.portme.com:1234/relative/int2"), | |
| 316 intercepts[1].target_url); | |
| 317 EXPECT_EQ(GURL("http://www.portme.com:1234/three"), | |
| 318 intercepts[2].namespace_url); | |
| 319 EXPECT_EQ(GURL("http://www.portme.com:1234/int3"), | |
| 320 intercepts[2].target_url); | |
| 321 | |
| 322 // Disallow intercepts ths time. | |
| 323 manifest = Manifest(); | |
| 324 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 325 PARSE_MANIFEST_PER_STANDARD, manifest)); | |
| 326 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 327 EXPECT_TRUE(manifest.explicit_urls.empty()); | |
| 328 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 329 EXPECT_TRUE(manifest.intercept_namespaces.empty()); | |
| 330 EXPECT_FALSE(manifest.online_whitelist_all); | |
| 331 } | |
| 332 | |
| 333 TEST(AppCacheManifestParserTest, ComboUrls) { | |
| 334 Manifest manifest; | |
| 335 const GURL kUrl("http://combo.com:42"); | |
| 336 const std::string kData("CACHE MANIFEST\r" | |
| 337 "relative/explicit-1\r" | |
| 338 "# some comment\r" | |
| 339 "http://combo.com:99/explicit-2#strip\r" | |
| 340 "NETWORK:\r" | |
| 341 "http://combo.com/whitelist-1\r" | |
| 342 "HTTP://www.diff.com/whitelist-2#strip\r" | |
| 343 "*\r" | |
| 344 "CACHE:\n\r" | |
| 345 "http://www.diff.com/explicit-3\r" | |
| 346 "FALLBACK:\r" | |
| 347 "http://combo.com:42/fallback-1 http://combo.com:42/fallback-1b\r" | |
| 348 "relative/fallback-2 relative/fallback-2b\r" | |
| 349 "UNKNOWN:\r\n" | |
| 350 "http://combo.com/ignoreme\r" | |
| 351 "relative/still-ignored\r" | |
| 352 "NETWORK:\r\n" | |
| 353 "relative/whitelist-3#strip\r" | |
| 354 "http://combo.com:99/whitelist-4\r"); | |
| 355 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 356 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 357 EXPECT_TRUE(manifest.online_whitelist_all); | |
| 358 | |
| 359 base::hash_set<std::string> urls = manifest.explicit_urls; | |
| 360 size_t expected = 3; | |
| 361 ASSERT_EQ(expected, urls.size()); | |
| 362 EXPECT_TRUE(urls.find("http://combo.com:42/relative/explicit-1") != | |
| 363 urls.end()); | |
| 364 EXPECT_TRUE(urls.find("http://combo.com:99/explicit-2") != urls.end()); | |
| 365 EXPECT_TRUE(urls.find("http://www.diff.com/explicit-3") != urls.end()); | |
| 366 | |
| 367 const AppCacheNamespaceVector& online = manifest.online_whitelist_namespaces; | |
| 368 expected = 4; | |
| 369 ASSERT_EQ(expected, online.size()); | |
| 370 EXPECT_EQ(GURL("http://combo.com/whitelist-1"), | |
| 371 online[0].namespace_url); | |
| 372 EXPECT_EQ(GURL("http://www.diff.com/whitelist-2"), | |
| 373 online[1].namespace_url); | |
| 374 EXPECT_EQ(GURL("http://combo.com:42/relative/whitelist-3"), | |
| 375 online[2].namespace_url); | |
| 376 EXPECT_EQ(GURL("http://combo.com:99/whitelist-4"), | |
| 377 online[3].namespace_url); | |
| 378 | |
| 379 const AppCacheNamespaceVector& fallbacks = manifest.fallback_namespaces; | |
| 380 expected = 2; | |
| 381 ASSERT_EQ(expected, fallbacks.size()); | |
| 382 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[0].type); | |
| 383 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, fallbacks[1].type); | |
| 384 EXPECT_EQ(GURL("http://combo.com:42/fallback-1"), | |
| 385 fallbacks[0].namespace_url); | |
| 386 EXPECT_EQ(GURL("http://combo.com:42/fallback-1b"), | |
| 387 fallbacks[0].target_url); | |
| 388 EXPECT_EQ(GURL("http://combo.com:42/relative/fallback-2"), | |
| 389 fallbacks[1].namespace_url); | |
| 390 EXPECT_EQ(GURL("http://combo.com:42/relative/fallback-2b"), | |
| 391 fallbacks[1].target_url); | |
| 392 | |
| 393 EXPECT_TRUE(manifest.intercept_namespaces.empty()); | |
| 394 } | |
| 395 | |
| 396 TEST(AppCacheManifestParserTest, UnusualUtf8) { | |
| 397 Manifest manifest; | |
| 398 const GURL kUrl("http://bad.com"); | |
| 399 const std::string kData("CACHE MANIFEST\r" | |
| 400 "\xC0" "invalidutf8\r" | |
| 401 "nonbmp" "\xF1\x84\xAB\xBC\r"); | |
| 402 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 403 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 404 base::hash_set<std::string> urls = manifest.explicit_urls; | |
| 405 EXPECT_TRUE(urls.find("http://bad.com/%EF%BF%BDinvalidutf8") != urls.end()); | |
| 406 EXPECT_TRUE(urls.find("http://bad.com/nonbmp%F1%84%AB%BC") != urls.end()); | |
| 407 } | |
| 408 | |
| 409 TEST(AppCacheManifestParserTest, IgnoreAfterSpace) { | |
| 410 Manifest manifest; | |
| 411 const GURL kUrl("http://smorg.borg"); | |
| 412 const std::string kData( | |
| 413 "CACHE MANIFEST\r" | |
| 414 "resource.txt this stuff after the white space should be ignored\r"); | |
| 415 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 416 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 417 | |
| 418 base::hash_set<std::string> urls = manifest.explicit_urls; | |
| 419 EXPECT_TRUE(urls.find("http://smorg.borg/resource.txt") != urls.end()); | |
| 420 } | |
| 421 | |
| 422 TEST(AppCacheManifestParserTest, DifferentOriginUrlWithSecureScheme) { | |
| 423 Manifest manifest; | |
| 424 const GURL kUrl("https://www.foo.com"); | |
| 425 const std::string kData("CACHE MANIFEST\r" | |
| 426 "CACHE: \r" | |
| 427 "relative/secureschemesameorigin\r" | |
| 428 "https://www.foo.com/secureschemesameorigin\r" | |
| 429 "http://www.xyz.com/secureschemedifforigin\r" | |
| 430 "https://www.xyz.com/secureschemedifforigin\r"); | |
| 431 | |
| 432 EXPECT_TRUE(ParseManifest(kUrl, kData.c_str(), kData.length(), | |
| 433 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 434 EXPECT_TRUE(manifest.fallback_namespaces.empty()); | |
| 435 EXPECT_TRUE(manifest.online_whitelist_namespaces.empty()); | |
| 436 | |
| 437 base::hash_set<std::string> urls = manifest.explicit_urls; | |
| 438 const size_t kExpected = 3; | |
| 439 ASSERT_EQ(kExpected, urls.size()); | |
| 440 EXPECT_TRUE(urls.find("https://www.foo.com/relative/secureschemesameorigin") | |
| 441 != urls.end()); | |
| 442 EXPECT_TRUE(urls.find("https://www.foo.com/secureschemesameorigin") != | |
| 443 urls.end()); | |
| 444 EXPECT_FALSE(urls.find("http://www.xyz.com/secureschemedifforigin") != | |
| 445 urls.end()); | |
| 446 EXPECT_TRUE(urls.find("https://www.xyz.com/secureschemedifforigin") != | |
| 447 urls.end()); | |
| 448 } | |
| 449 | |
| 450 TEST(AppCacheManifestParserTest, PatternMatching) { | |
| 451 const GURL kUrl("http://foo.com/manifest"); | |
| 452 const std::string kManifestBody( | |
| 453 "CACHE MANIFEST\r" | |
| 454 "CACHE: \r" | |
| 455 "http://foo.com/page.html\r" | |
| 456 "CHROMIUM-INTERCEPT:\r" | |
| 457 "http://foo.com/intercept_prefix return /prefix\r" | |
| 458 "http://foo.com/intercept_pattern return /pattern isPattern\r" | |
| 459 "http://foo.com/*/intercept_pattern?query return /pattern isPattern\r" | |
| 460 "FALLBACK:\r" | |
| 461 "http://foo.com/fallback_prefix /prefix wrongAnnotation\r" | |
| 462 "http://foo.com/fallback_pattern* /pattern\tisPattern \r" | |
| 463 "NETWORK:\r" | |
| 464 "*\r" | |
| 465 "isPattern\r" // should not be interpretted as a pattern | |
| 466 "http://foo.com/network_pattern* isPattern\r"); | |
| 467 | |
| 468 | |
| 469 Manifest manifest; | |
| 470 EXPECT_TRUE(ParseManifest(kUrl, kManifestBody.c_str(), | |
| 471 kManifestBody.length(), | |
| 472 PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest)); | |
| 473 EXPECT_TRUE(manifest.online_whitelist_all); | |
| 474 EXPECT_EQ(1u, manifest.explicit_urls.size()); | |
| 475 EXPECT_EQ(3u, manifest.intercept_namespaces.size()); | |
| 476 EXPECT_EQ(2u, manifest.fallback_namespaces.size()); | |
| 477 EXPECT_EQ(2u, manifest.online_whitelist_namespaces.size()); | |
| 478 EXPECT_EQ(APPCACHE_INTERCEPT_NAMESPACE, | |
| 479 manifest.intercept_namespaces[0].type); | |
| 480 EXPECT_EQ(APPCACHE_FALLBACK_NAMESPACE, manifest.fallback_namespaces[0].type); | |
| 481 EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE, | |
| 482 manifest.online_whitelist_namespaces[0].type); | |
| 483 EXPECT_FALSE(manifest.intercept_namespaces[0].is_pattern); | |
| 484 EXPECT_TRUE(manifest.intercept_namespaces[1].is_pattern); | |
| 485 EXPECT_TRUE(manifest.intercept_namespaces[2].is_pattern); | |
| 486 EXPECT_FALSE(manifest.fallback_namespaces[0].is_pattern); | |
| 487 EXPECT_TRUE(manifest.fallback_namespaces[1].is_pattern); | |
| 488 EXPECT_FALSE(manifest.online_whitelist_namespaces[0].is_pattern); | |
| 489 EXPECT_TRUE(manifest.online_whitelist_namespaces[1].is_pattern); | |
| 490 EXPECT_EQ( | |
| 491 GURL("http://foo.com/*/intercept_pattern?query"), | |
| 492 manifest.intercept_namespaces[2].namespace_url); | |
| 493 EXPECT_EQ( | |
| 494 GURL("http://foo.com/pattern"), | |
| 495 manifest.intercept_namespaces[2].target_url); | |
| 496 EXPECT_EQ( | |
| 497 GURL("http://foo.com/fallback_pattern*"), | |
| 498 manifest.fallback_namespaces[1].namespace_url); | |
| 499 EXPECT_EQ( | |
| 500 GURL("http://foo.com/pattern"), | |
| 501 manifest.fallback_namespaces[1].target_url); | |
| 502 EXPECT_EQ( | |
| 503 GURL("http://foo.com/isPattern"), | |
| 504 manifest.online_whitelist_namespaces[0].namespace_url); | |
| 505 EXPECT_EQ( | |
| 506 GURL(), | |
| 507 manifest.online_whitelist_namespaces[0].target_url); | |
| 508 EXPECT_EQ( | |
| 509 GURL("http://foo.com/network_pattern*"), | |
| 510 manifest.online_whitelist_namespaces[1].namespace_url); | |
| 511 EXPECT_EQ( | |
| 512 GURL(), | |
| 513 manifest.online_whitelist_namespaces[1].target_url); | |
| 514 } | |
| 515 | |
| 516 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 493383003:
Revert 291388 "Rename appcache/manifest_parser* to appcache/appc..." (Closed)
Base URL: svn://svn.chromium.org/chrome/