OLD | NEW |
---|---|
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "chrome/browser/extensions/extension_special_storage_policy.h" | 5 #include "chrome/browser/extensions/extension_special_storage_policy.h" |
6 | 6 |
7 #include "base/command_line.h" | |
7 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "chrome/common/chrome_switches.h" | |
8 #include "chrome/common/extensions/extension.h" | 10 #include "chrome/common/extensions/extension.h" |
9 #include "chrome/common/url_constants.h" | 11 #include "chrome/common/url_constants.h" |
10 | 12 |
11 ExtensionSpecialStoragePolicy::ExtensionSpecialStoragePolicy() {} | 13 ExtensionSpecialStoragePolicy::ExtensionSpecialStoragePolicy() {} |
12 | 14 |
13 ExtensionSpecialStoragePolicy::~ExtensionSpecialStoragePolicy() {} | 15 ExtensionSpecialStoragePolicy::~ExtensionSpecialStoragePolicy() {} |
14 | 16 |
15 bool ExtensionSpecialStoragePolicy::IsStorageProtected(const GURL& origin) { | 17 bool ExtensionSpecialStoragePolicy::IsStorageProtected(const GURL& origin) { |
16 if (origin.SchemeIs(chrome::kExtensionScheme)) | 18 if (origin.SchemeIs(chrome::kExtensionScheme)) |
17 return true; | 19 return true; |
18 base::AutoLock locker(lock_); | 20 base::AutoLock locker(lock_); |
19 return protected_apps_.Contains(origin); | 21 return protected_apps_.Contains(origin); |
20 } | 22 } |
21 | 23 |
22 bool ExtensionSpecialStoragePolicy::IsStorageUnlimited(const GURL& origin) { | 24 bool ExtensionSpecialStoragePolicy::IsStorageUnlimited(const GURL& origin) { |
23 base::AutoLock locker(lock_); | 25 base::AutoLock locker(lock_); |
24 return unlimited_extensions_.Contains(origin); | 26 return unlimited_extensions_.Contains(origin); |
25 } | 27 } |
26 | 28 |
27 bool ExtensionSpecialStoragePolicy::IsLocalFileSystemAccessAllowed( | 29 bool ExtensionSpecialStoragePolicy::IsLocalFileSystemAccessAllowed( |
28 const GURL& origin) { | 30 const GURL& origin, const FilePath& virtual_path) { |
29 base::AutoLock locker(lock_); | 31 base::AutoLock locker(lock_); |
30 return local_filesystem_extensions_.Contains(origin); | 32 return local_filesystem_extensions_.ContainsPath(origin, virtual_path); |
33 } | |
34 | |
35 void ExtensionSpecialStoragePolicy::GrantLocalFileSystemAccess( | |
36 const GURL& origin, const FilePath& virtual_path) { | |
37 base::AutoLock locker(lock_); | |
38 local_filesystem_extensions_.AddPath(origin, virtual_path); | |
31 } | 39 } |
32 | 40 |
33 void ExtensionSpecialStoragePolicy::GrantRightsForExtension( | 41 void ExtensionSpecialStoragePolicy::GrantRightsForExtension( |
34 const Extension* extension) { | 42 const Extension* extension) { |
35 DCHECK(extension); | 43 DCHECK(extension); |
36 if (!extension->is_hosted_app() && | 44 if (!extension->is_hosted_app() && |
37 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && | 45 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && |
38 !extension->HasApiPermission(Extension::kFileSystemPermission)) { | 46 !extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) { |
39 return; | 47 return; |
40 } | 48 } |
41 base::AutoLock locker(lock_); | 49 base::AutoLock locker(lock_); |
42 if (extension->is_hosted_app()) | 50 if (extension->is_hosted_app()) |
43 protected_apps_.Add(extension); | 51 protected_apps_.Add(extension); |
44 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) | 52 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) |
45 unlimited_extensions_.Add(extension); | 53 unlimited_extensions_.Add(extension); |
46 if (extension->HasApiPermission(Extension::kFileSystemPermission)) | 54 if (extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) |
47 local_filesystem_extensions_.Add(extension); | 55 local_filesystem_extensions_.Add(extension); |
48 } | 56 } |
49 | 57 |
50 void ExtensionSpecialStoragePolicy::RevokeRightsForExtension( | 58 void ExtensionSpecialStoragePolicy::RevokeRightsForExtension( |
51 const Extension* extension) { | 59 const Extension* extension) { |
52 DCHECK(extension); | 60 DCHECK(extension); |
53 if (!extension->is_hosted_app() && | 61 if (!extension->is_hosted_app() && |
54 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && | 62 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && |
55 !extension->HasApiPermission(Extension::kFileSystemPermission)) { | 63 !extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) { |
56 return; | 64 return; |
57 } | 65 } |
58 base::AutoLock locker(lock_); | 66 base::AutoLock locker(lock_); |
59 if (extension->is_hosted_app()) | 67 if (extension->is_hosted_app()) |
60 protected_apps_.Remove(extension); | 68 protected_apps_.Remove(extension); |
61 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) | 69 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) |
62 unlimited_extensions_.Remove(extension); | 70 unlimited_extensions_.Remove(extension); |
63 if (extension->HasApiPermission(Extension::kFileSystemPermission)) | 71 if (extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) |
64 local_filesystem_extensions_.Remove(extension); | 72 local_filesystem_extensions_.Remove(extension); |
65 } | 73 } |
66 | 74 |
67 void ExtensionSpecialStoragePolicy::RevokeRightsForAllExtensions() { | 75 void ExtensionSpecialStoragePolicy::RevokeRightsForAllExtensions() { |
68 base::AutoLock locker(lock_); | 76 base::AutoLock locker(lock_); |
69 protected_apps_.Clear(); | 77 protected_apps_.Clear(); |
70 unlimited_extensions_.Clear(); | 78 unlimited_extensions_.Clear(); |
71 local_filesystem_extensions_.Clear(); | 79 local_filesystem_extensions_.Clear(); |
72 } | 80 } |
73 | 81 |
74 //----------------------------------------------------------------------------- | 82 //----------------------------------------------------------------------------- |
75 // SpecialCollection helper class | 83 // SpecialCollection helper class |
76 //----------------------------------------------------------------------------- | 84 //----------------------------------------------------------------------------- |
77 | 85 |
78 ExtensionSpecialStoragePolicy::SpecialCollection::SpecialCollection() {} | 86 ExtensionSpecialStoragePolicy::SpecialCollection::SpecialCollection() {} |
79 | 87 |
80 ExtensionSpecialStoragePolicy::SpecialCollection::~SpecialCollection() {} | 88 ExtensionSpecialStoragePolicy::SpecialCollection::~SpecialCollection() {} |
81 | 89 |
82 bool ExtensionSpecialStoragePolicy::SpecialCollection::Contains( | 90 bool ExtensionSpecialStoragePolicy::SpecialCollection::Contains( |
83 const GURL& origin) { | 91 const GURL& origin) { |
84 CachedResults::const_iterator found = cached_resuts_.find(origin); | 92 CachedResults::const_iterator found = cached_results_.find(origin); |
85 if (found != cached_resuts_.end()) | 93 if (found != cached_results_.end()) |
86 return found->second; | 94 return found->second; |
87 | 95 |
88 for (Extensions::const_iterator iter = extensions_.begin(); | 96 for (Extensions::const_iterator iter = extensions_.begin(); |
89 iter != extensions_.end(); ++iter) { | 97 iter != extensions_.end(); ++iter) { |
90 if (iter->second->OverlapsWithOrigin(origin)) { | 98 if (iter->second->OverlapsWithOrigin(origin)) { |
91 cached_resuts_[origin] = true; | 99 cached_results_[origin] = true; |
92 return true; | 100 return true; |
93 } | 101 } |
94 } | 102 } |
95 cached_resuts_[origin] = false; | 103 cached_results_[origin] = false; |
96 return false; | 104 return false; |
97 } | 105 } |
98 | 106 |
99 void ExtensionSpecialStoragePolicy::SpecialCollection::Add( | 107 void ExtensionSpecialStoragePolicy::SpecialCollection::Add( |
100 const Extension* extension) { | 108 const Extension* extension) { |
101 cached_resuts_.clear(); | 109 cached_results_.clear(); |
102 extensions_[extension->id()] = extension; | 110 extensions_[extension->id()] = extension; |
103 } | 111 } |
104 | 112 |
105 void ExtensionSpecialStoragePolicy::SpecialCollection::Remove( | 113 void ExtensionSpecialStoragePolicy::SpecialCollection::Remove( |
106 const Extension* extension) { | 114 const Extension* extension) { |
107 cached_resuts_.clear(); | 115 cached_results_.clear(); |
108 extensions_.erase(extension->id()); | 116 extensions_.erase(extension->id()); |
109 } | 117 } |
110 | 118 |
111 void ExtensionSpecialStoragePolicy::SpecialCollection::Clear() { | 119 void ExtensionSpecialStoragePolicy::SpecialCollection::Clear() { |
112 cached_resuts_.clear(); | 120 cached_results_.clear(); |
113 extensions_.clear(); | 121 extensions_.clear(); |
114 } | 122 } |
123 | |
124 //----------------------------------------------------------------------------- | |
125 // SpecialPathCollection helper class | |
126 //----------------------------------------------------------------------------- | |
127 | |
128 ExtensionSpecialStoragePolicy::SpecialPathCollection::SpecialPathCollection() {} | |
129 | |
130 ExtensionSpecialStoragePolicy::SpecialPathCollection::~SpecialPathCollection() { | |
131 } | |
132 | |
133 void ExtensionSpecialStoragePolicy::SpecialPathCollection::Clear() { | |
134 SpecialCollection::Clear(); | |
135 path_map_.clear(); | |
136 } | |
137 | |
138 void ExtensionSpecialStoragePolicy::SpecialPathCollection::Remove( | |
139 const Extension* extension) { | |
140 SpecialCollection::Remove(extension); | |
141 path_map_.erase(extension); | |
142 } | |
143 | |
144 void ExtensionSpecialStoragePolicy::SpecialPathCollection::AddPath( | |
145 const GURL& origin, const FilePath& path) { | |
146 scoped_refptr<const Extension> extension = GetExtension(origin); | |
147 if (!extension.get()) | |
148 return; | |
149 PathAccessMap::iterator path_map_iter = path_map_.find(extension); | |
150 if (path_map_iter == path_map_.end()) { | |
151 PathSet path_set; | |
152 path_set.insert(path); | |
153 path_map_.insert(PathAccessMap::value_type(extension, path_set)); | |
154 } else { | |
155 if (path_map_iter->second.find(path) != path_map_iter->second.end()) | |
156 return; | |
157 path_map_iter->second.insert(path); | |
158 } | |
159 } | |
160 | |
161 bool ExtensionSpecialStoragePolicy::SpecialPathCollection::ContainsPath( | |
162 const GURL& origin, const FilePath& path) { | |
163 scoped_refptr<const Extension> extension = GetExtension(origin); | |
164 if (!extension.get()) | |
165 return false; | |
166 | |
167 // Allow access to any local path from component extensions. | |
168 if (extension->location() == Extension::COMPONENT | |
169 #ifndef NDEBUG | |
170 || CommandLine::ForCurrentProcess()->HasSwitch( | |
171 switches::kExposePrivateExtensionApi) | |
172 #endif | |
173 ) { | |
174 return true; | |
175 } | |
176 | |
177 PathAccessMap::const_iterator path_map_iter = path_map_.find(extension); | |
178 if (path_map_iter == path_map_.end()) | |
179 return false; | |
180 | |
181 // Check this file and walk up its directory tree to find if this extension | |
182 // has access to it. | |
183 FilePath current_path = path.StripTrailingSeparators(); | |
184 FilePath last_path; | |
185 while (current_path != last_path) { | |
186 if (path_map_iter->second.find(current_path) != path_map_iter->second.end()) | |
187 return true; | |
188 last_path = current_path; | |
189 current_path = current_path.DirName(); | |
190 } | |
191 return false; | |
192 } | |
193 | |
194 scoped_refptr<const Extension> | |
195 ExtensionSpecialStoragePolicy::SpecialPathCollection::GetExtension( | |
196 const GURL& origin) { | |
197 for (Extensions::const_iterator iter = extensions_.begin(); | |
198 iter != extensions_.end(); ++iter) { | |
199 if (iter->second->OverlapsWithOrigin(origin)) | |
michaeln
2011/04/14 01:26:26
ooops... forgot to hit send earlier today...
Cons
| |
200 return iter->second; | |
201 } | |
202 return scoped_refptr<const Extension>(); | |
203 } | |
OLD | NEW |