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" | |
michaeln
2011/04/14 21:25:34
still needed?
zel
2011/04/14 21:46:20
Done.
| |
7 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "chrome/common/chrome_switches.h" | |
michaeln
2011/04/14 21:25:34
still needed?
zel
2011/04/14 21:46:20
Done.
| |
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::IsFileHanlder( |
28 const GURL& origin) { | 30 const std::string& extension_id) { |
29 base::AutoLock locker(lock_); | 31 base::AutoLock locker(lock_); |
30 return local_filesystem_extensions_.Contains(origin); | 32 return file_handler_extensions_.ContainsExtension(extension_id); |
31 } | 33 } |
32 | 34 |
33 void ExtensionSpecialStoragePolicy::GrantRightsForExtension( | 35 void ExtensionSpecialStoragePolicy::GrantRightsForExtension( |
34 const Extension* extension) { | 36 const Extension* extension) { |
35 DCHECK(extension); | 37 DCHECK(extension); |
36 if (!extension->is_hosted_app() && | 38 if (!extension->is_hosted_app() && |
37 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && | 39 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && |
38 !extension->HasApiPermission(Extension::kFileSystemPermission)) { | 40 !extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) { |
39 return; | 41 return; |
40 } | 42 } |
41 base::AutoLock locker(lock_); | 43 base::AutoLock locker(lock_); |
42 if (extension->is_hosted_app()) | 44 if (extension->is_hosted_app()) |
43 protected_apps_.Add(extension); | 45 protected_apps_.Add(extension); |
44 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) | 46 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) |
45 unlimited_extensions_.Add(extension); | 47 unlimited_extensions_.Add(extension); |
46 if (extension->HasApiPermission(Extension::kFileSystemPermission)) | 48 if (extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) |
47 local_filesystem_extensions_.Add(extension); | 49 file_handler_extensions_.Add(extension); |
48 } | 50 } |
49 | 51 |
50 void ExtensionSpecialStoragePolicy::RevokeRightsForExtension( | 52 void ExtensionSpecialStoragePolicy::RevokeRightsForExtension( |
51 const Extension* extension) { | 53 const Extension* extension) { |
52 DCHECK(extension); | 54 DCHECK(extension); |
53 if (!extension->is_hosted_app() && | 55 if (!extension->is_hosted_app() && |
54 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && | 56 !extension->HasApiPermission(Extension::kUnlimitedStoragePermission) && |
55 !extension->HasApiPermission(Extension::kFileSystemPermission)) { | 57 !extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) { |
56 return; | 58 return; |
57 } | 59 } |
58 base::AutoLock locker(lock_); | 60 base::AutoLock locker(lock_); |
59 if (extension->is_hosted_app()) | 61 if (extension->is_hosted_app()) |
60 protected_apps_.Remove(extension); | 62 protected_apps_.Remove(extension); |
61 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) | 63 if (extension->HasApiPermission(Extension::kUnlimitedStoragePermission)) |
62 unlimited_extensions_.Remove(extension); | 64 unlimited_extensions_.Remove(extension); |
63 if (extension->HasApiPermission(Extension::kFileSystemPermission)) | 65 if (extension->HasApiPermission(Extension::kFileBrowserHandlerPermission)) |
64 local_filesystem_extensions_.Remove(extension); | 66 file_handler_extensions_.Remove(extension); |
65 } | 67 } |
66 | 68 |
67 void ExtensionSpecialStoragePolicy::RevokeRightsForAllExtensions() { | 69 void ExtensionSpecialStoragePolicy::RevokeRightsForAllExtensions() { |
68 base::AutoLock locker(lock_); | 70 base::AutoLock locker(lock_); |
69 protected_apps_.Clear(); | 71 protected_apps_.Clear(); |
70 unlimited_extensions_.Clear(); | 72 unlimited_extensions_.Clear(); |
71 local_filesystem_extensions_.Clear(); | 73 file_handler_extensions_.Clear(); |
72 } | 74 } |
73 | 75 |
74 //----------------------------------------------------------------------------- | 76 //----------------------------------------------------------------------------- |
75 // SpecialCollection helper class | 77 // SpecialCollection helper class |
76 //----------------------------------------------------------------------------- | 78 //----------------------------------------------------------------------------- |
77 | 79 |
78 ExtensionSpecialStoragePolicy::SpecialCollection::SpecialCollection() {} | 80 ExtensionSpecialStoragePolicy::SpecialCollection::SpecialCollection() {} |
79 | 81 |
80 ExtensionSpecialStoragePolicy::SpecialCollection::~SpecialCollection() {} | 82 ExtensionSpecialStoragePolicy::SpecialCollection::~SpecialCollection() {} |
81 | 83 |
82 bool ExtensionSpecialStoragePolicy::SpecialCollection::Contains( | 84 bool ExtensionSpecialStoragePolicy::SpecialCollection::Contains( |
83 const GURL& origin) { | 85 const GURL& origin) { |
84 CachedResults::const_iterator found = cached_resuts_.find(origin); | 86 CachedResults::const_iterator found = cached_results_.find(origin); |
85 if (found != cached_resuts_.end()) | 87 if (found != cached_results_.end()) |
86 return found->second; | 88 return found->second; |
87 | 89 |
88 for (Extensions::const_iterator iter = extensions_.begin(); | 90 for (Extensions::const_iterator iter = extensions_.begin(); |
89 iter != extensions_.end(); ++iter) { | 91 iter != extensions_.end(); ++iter) { |
90 if (iter->second->OverlapsWithOrigin(origin)) { | 92 if (iter->second->OverlapsWithOrigin(origin)) { |
91 cached_resuts_[origin] = true; | 93 cached_results_[origin] = true; |
92 return true; | 94 return true; |
93 } | 95 } |
94 } | 96 } |
95 cached_resuts_[origin] = false; | 97 cached_results_[origin] = false; |
96 return false; | 98 return false; |
97 } | 99 } |
98 | 100 |
101 bool ExtensionSpecialStoragePolicy::SpecialCollection::ContainsExtension( | |
102 const std::string& extension_id) { | |
103 return extensions_.find(extension_id) != extensions_.end(); | |
104 } | |
105 | |
99 void ExtensionSpecialStoragePolicy::SpecialCollection::Add( | 106 void ExtensionSpecialStoragePolicy::SpecialCollection::Add( |
100 const Extension* extension) { | 107 const Extension* extension) { |
101 cached_resuts_.clear(); | 108 cached_results_.clear(); |
102 extensions_[extension->id()] = extension; | 109 extensions_[extension->id()] = extension; |
103 } | 110 } |
104 | 111 |
105 void ExtensionSpecialStoragePolicy::SpecialCollection::Remove( | 112 void ExtensionSpecialStoragePolicy::SpecialCollection::Remove( |
106 const Extension* extension) { | 113 const Extension* extension) { |
107 cached_resuts_.clear(); | 114 cached_results_.clear(); |
108 extensions_.erase(extension->id()); | 115 extensions_.erase(extension->id()); |
109 } | 116 } |
110 | 117 |
111 void ExtensionSpecialStoragePolicy::SpecialCollection::Clear() { | 118 void ExtensionSpecialStoragePolicy::SpecialCollection::Clear() { |
112 cached_resuts_.clear(); | 119 cached_results_.clear(); |
113 extensions_.clear(); | 120 extensions_.clear(); |
114 } | 121 } |
OLD | NEW |