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 "content/common/url_schemes.h" | 5 #include "content/common/url_schemes.h" |
6 | 6 |
7 #include <string.h> | 7 #include <string.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <string> | |
11 #include <vector> | |
12 | 10 |
13 #include "base/strings/string_util.h" | 11 #include "base/strings/string_util.h" |
14 #include "content/common/savable_url_schemes.h" | |
15 #include "content/public/common/content_client.h" | 12 #include "content/public/common/content_client.h" |
16 #include "content/public/common/url_constants.h" | 13 #include "content/public/common/url_constants.h" |
17 #include "url/url_util.h" | 14 #include "url/url_util.h" |
18 | 15 |
| 16 namespace content { |
19 namespace { | 17 namespace { |
20 | 18 |
| 19 // These lists are lazily initialized below and are leaked on shutdown to |
| 20 // prevent any destructors from being called that will slow us down or cause |
| 21 // problems. |
| 22 std::vector<std::string>* savable_schemes = nullptr; |
| 23 std::vector<std::string>* secure_schemes = nullptr; |
| 24 // Note we store GURLs here instead of strings to deal with canonicalization. |
| 25 std::vector<GURL>* secure_origins = nullptr; |
| 26 std::vector<std::string>* service_worker_schemes = nullptr; |
| 27 |
| 28 const char* const kDefaultSavableSchemes[] = { |
| 29 url::kHttpScheme, |
| 30 url::kHttpsScheme, |
| 31 url::kFileScheme, |
| 32 url::kFileSystemScheme, |
| 33 url::kFtpScheme, |
| 34 kChromeDevToolsScheme, |
| 35 kChromeUIScheme, |
| 36 url::kDataScheme |
| 37 }; |
| 38 |
21 } // namespace | 39 } // namespace |
22 | 40 |
23 namespace content { | |
24 | |
25 void RegisterContentSchemes(bool lock_schemes) { | 41 void RegisterContentSchemes(bool lock_schemes) { |
26 std::vector<url::SchemeWithType> additional_standard_schemes; | 42 ContentClient::Schemes schemes; |
27 std::vector<url::SchemeWithType> additional_referrer_schemes; | 43 GetContentClient()->AddAdditionalSchemes(&schemes); |
28 std::vector<std::string> additional_savable_schemes; | |
29 | |
30 GetContentClient()->AddAdditionalSchemes(&additional_standard_schemes, | |
31 &additional_referrer_schemes, | |
32 &additional_savable_schemes); | |
33 | 44 |
34 url::AddStandardScheme(kChromeDevToolsScheme, url::SCHEME_WITHOUT_PORT); | 45 url::AddStandardScheme(kChromeDevToolsScheme, url::SCHEME_WITHOUT_PORT); |
35 url::AddStandardScheme(kChromeUIScheme, url::SCHEME_WITHOUT_PORT); | 46 url::AddStandardScheme(kChromeUIScheme, url::SCHEME_WITHOUT_PORT); |
36 url::AddStandardScheme(kGuestScheme, url::SCHEME_WITHOUT_PORT); | 47 url::AddStandardScheme(kGuestScheme, url::SCHEME_WITHOUT_PORT); |
37 | 48 |
38 for (const url::SchemeWithType& scheme : additional_standard_schemes) | 49 for (auto& scheme : schemes.standard_schemes) |
39 url::AddStandardScheme(scheme.scheme, scheme.type); | 50 url::AddStandardScheme(scheme.c_str(), url::SCHEME_WITHOUT_PORT); |
40 | 51 |
41 for (const url::SchemeWithType& scheme : additional_referrer_schemes) | 52 for (auto& scheme : schemes.referrer_schemes) |
42 url::AddReferrerScheme(scheme.scheme, scheme.type); | 53 url::AddReferrerScheme(scheme.c_str(), url::SCHEME_WITHOUT_PORT); |
43 | 54 |
44 // Prevent future modification of the scheme lists. This is to prevent | 55 // Prevent future modification of the scheme lists. This is to prevent |
45 // accidental creation of data races in the program. Add*Scheme aren't | 56 // accidental creation of data races in the program. Add*Scheme aren't |
46 // threadsafe so must be called when GURL isn't used on any other thread. This | 57 // threadsafe so must be called when GURL isn't used on any other thread. This |
47 // is really easy to mess up, so we say that all calls to Add*Scheme in Chrome | 58 // is really easy to mess up, so we say that all calls to Add*Scheme in Chrome |
48 // must be inside this function. | 59 // must be inside this function. |
49 if (lock_schemes) | 60 if (lock_schemes) |
50 url::LockSchemeRegistries(); | 61 url::LockSchemeRegistries(); |
51 | 62 |
52 // We rely on the above lock to protect this part from being invoked twice. | 63 // Combine the default savable schemes with the additional ones given. |
53 if (!additional_savable_schemes.empty()) { | 64 savable_schemes = new std::vector<std::string>; |
54 const char* const* default_schemes = GetSavableSchemesInternal(); | 65 for (auto& default_scheme : kDefaultSavableSchemes) |
55 const char* const* default_schemes_end = NULL; | 66 savable_schemes->push_back(default_scheme); |
56 for (default_schemes_end = default_schemes; *default_schemes_end; | 67 savable_schemes->insert(savable_schemes->end(), |
57 ++default_schemes_end) {} | 68 schemes.savable_schemes.begin(), |
58 const int default_schemes_count = default_schemes_end - default_schemes; | 69 schemes.savable_schemes.end()); |
59 | 70 |
60 int schemes = static_cast<int>(additional_savable_schemes.size()); | 71 secure_schemes = new std::vector<std::string>; |
61 // The array, and the copied schemes won't be freed, but will remain | 72 *secure_schemes = std::move(schemes.secure_schemes); |
62 // reachable. | |
63 char **savable_schemes = new char*[schemes + default_schemes_count + 1]; | |
64 memcpy(savable_schemes, | |
65 default_schemes, | |
66 default_schemes_count * sizeof(default_schemes[0])); | |
67 for (int i = 0; i < schemes; ++i) { | |
68 savable_schemes[default_schemes_count + i] = | |
69 base::strdup(additional_savable_schemes[i].c_str()); | |
70 } | |
71 savable_schemes[default_schemes_count + schemes] = 0; | |
72 | 73 |
73 SetSavableSchemes(savable_schemes); | 74 service_worker_schemes = new std::vector<std::string>; |
74 } | 75 *service_worker_schemes = std::move(schemes.service_worker_schemes); |
| 76 |
| 77 secure_origins = new std::vector<GURL>; |
| 78 *secure_origins = std::move(schemes.secure_origins); |
| 79 } |
| 80 |
| 81 const std::vector<std::string>& GetSavableSchemes() { |
| 82 return *savable_schemes; |
| 83 } |
| 84 |
| 85 const std::vector<std::string>& GetSecureSchemes() { |
| 86 return *secure_schemes; |
| 87 } |
| 88 |
| 89 const std::vector<GURL>& GetSecureOrigins() { |
| 90 return *secure_origins; |
| 91 } |
| 92 |
| 93 const std::vector<std::string>& GetServiceWorkerSchemes() { |
| 94 return *service_worker_schemes; |
| 95 } |
| 96 |
| 97 void RefreshSecuritySchemesForTesting() { |
| 98 ContentClient::Schemes schemes; |
| 99 GetContentClient()->AddAdditionalSchemes(&schemes); |
| 100 |
| 101 *secure_schemes = std::move(schemes.secure_schemes); |
| 102 *service_worker_schemes = std::move(schemes.service_worker_schemes); |
| 103 *secure_origins = std::move(schemes.secure_origins); |
75 } | 104 } |
76 | 105 |
77 } // namespace content | 106 } // namespace content |
OLD | NEW |