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 "chrome/browser/cookies_tree_model.h" | 5 #include "chrome/browser/cookies_tree_model.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <functional> | 8 #include <functional> |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
11 #include "base/bind.h" | 11 #include "base/bind.h" |
12 #include "base/memory/linked_ptr.h" | 12 #include "base/memory/linked_ptr.h" |
13 #include "base/string_util.h" | 13 #include "base/string_util.h" |
14 #include "base/utf_string_conversions.h" | 14 #include "base/utf_string_conversions.h" |
15 #include "chrome/browser/browsing_data_cookie_helper.h" | 15 #include "chrome/browser/browsing_data_cookie_helper.h" |
16 #include "chrome/browser/browsing_data_server_bound_cert_helper.h" | 16 #include "chrome/browser/browsing_data_server_bound_cert_helper.h" |
17 #include "chrome/browser/content_settings/cookie_settings.h" | 17 #include "chrome/browser/content_settings/cookie_settings.h" |
18 #include "chrome/browser/extensions/extension_service.h" | 18 #include "chrome/browser/extensions/extension_service.h" |
| 19 #include "chrome/browser/extensions/extension_special_storage_policy.h" |
19 #include "content/public/common/url_constants.h" | 20 #include "content/public/common/url_constants.h" |
20 #include "grit/generated_resources.h" | 21 #include "grit/generated_resources.h" |
21 #include "grit/theme_resources.h" | 22 #include "grit/theme_resources.h" |
22 #include "grit/ui_resources.h" | 23 #include "grit/ui_resources.h" |
23 #include "net/base/registry_controlled_domain.h" | 24 #include "net/base/registry_controlled_domain.h" |
24 #include "net/cookies/cookie_monster.h" | 25 #include "net/cookies/cookie_monster.h" |
25 #include "net/url_request/url_request_context.h" | 26 #include "net/url_request/url_request_context.h" |
26 #include "ui/base/l10n/l10n_util.h" | 27 #include "ui/base/l10n/l10n_util.h" |
27 #include "ui/base/resource/resource_bundle.h" | 28 #include "ui/base/resource/resource_bundle.h" |
28 #include "ui/gfx/image/image_skia.h" | 29 #include "ui/gfx/image/image_skia.h" |
29 | 30 |
30 namespace { | 31 namespace { |
31 | 32 |
32 struct NodeTitleComparator { | 33 struct NodeTitleComparator { |
33 bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) { | 34 bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) { |
34 return lhs->GetTitle() < rhs->GetTitle(); | 35 return lhs->GetTitle() < rhs->GetTitle(); |
35 } | 36 } |
36 }; | 37 }; |
37 | 38 |
38 // Comparison functor, for use in CookieTreeRootNode. | 39 // Comparison functor, for use in CookieTreeRootNode. |
39 struct OriginNodeComparator { | 40 struct HostNodeComparator { |
40 bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) { | 41 bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) { |
41 // This comparator is only meant to compare CookieTreeOriginNode types. Make | 42 // This comparator is only meant to compare CookieTreeHostNode types. Make |
42 // sure we check this, as the static cast below is dangerous if we get the | 43 // sure we check this, as the static cast below is dangerous if we get the |
43 // wrong object type. | 44 // wrong object type. |
44 CHECK_EQ(lhs->GetDetailedInfo().node_type, | 45 CHECK_EQ(CookieTreeNode::DetailedInfo::TYPE_HOST, |
45 CookieTreeNode::DetailedInfo::TYPE_ORIGIN); | 46 lhs->GetDetailedInfo().node_type); |
46 CHECK_EQ(rhs->GetDetailedInfo().node_type, | 47 CHECK_EQ(CookieTreeNode::DetailedInfo::TYPE_HOST, |
47 CookieTreeNode::DetailedInfo::TYPE_ORIGIN); | 48 rhs->GetDetailedInfo().node_type); |
48 | 49 |
49 const CookieTreeOriginNode* ltn = | 50 const CookieTreeHostNode* ltn = |
50 static_cast<const CookieTreeOriginNode*>(lhs); | 51 static_cast<const CookieTreeHostNode*>(lhs); |
51 const CookieTreeOriginNode* rtn = | 52 const CookieTreeHostNode* rtn = |
52 static_cast<const CookieTreeOriginNode*>(rhs); | 53 static_cast<const CookieTreeHostNode*>(rhs); |
53 | 54 |
54 if (ltn->app_id() != rtn->app_id()) { | 55 if (ltn->app_id() != rtn->app_id()) { |
55 return (ltn->app_name() < rtn->app_name()); | 56 return (ltn->app_name() < rtn->app_name()); |
56 } | 57 } |
57 | 58 |
58 // We want to order by registry controlled domain, so we would get | 59 // We want to order by registry controlled domain, so we would get |
59 // google.com, ad.google.com, www.google.com, | 60 // google.com, ad.google.com, www.google.com, |
60 // microsoft.com, ad.microsoft.com. CanonicalizeHost transforms the origins | 61 // microsoft.com, ad.microsoft.com. CanonicalizeHost transforms the origins |
61 // into a form like google.com.www so that string comparisons work. | 62 // into a form like google.com.www so that string comparisons work. |
62 return (CanonicalizeHost(ltn->GetHost()) < | 63 return (ltn->canonicalized_host() < |
63 CanonicalizeHost(rtn->GetHost())); | 64 rtn->canonicalized_host()); |
| 65 } |
| 66 }; |
| 67 |
| 68 std::string CanonicalizeHost(const GURL& url) { |
| 69 // The canonicalized representation makes the registry controlled domain |
| 70 // come first, and then adds subdomains in reverse order, e.g. |
| 71 // 1.mail.google.com would become google.com.mail.1, and then a standard |
| 72 // string comparison works to order hosts by registry controlled domain |
| 73 // first. Leading dots are ignored, ".google.com" is the same as |
| 74 // "google.com". |
| 75 |
| 76 if (url.SchemeIsFile()) { |
| 77 return std::string(chrome::kFileScheme) + |
| 78 content::kStandardSchemeSeparator; |
64 } | 79 } |
65 | 80 |
66 static std::string CanonicalizeHost(const std::string& host) { | 81 std::string host = url.host(); |
67 // The canonicalized representation makes the registry controlled domain | 82 std::string retval = net::RegistryControlledDomainService:: |
68 // come first, and then adds subdomains in reverse order, e.g. | 83 GetDomainAndRegistry(host); |
69 // 1.mail.google.com would become google.com.mail.1, and then a standard | 84 if (!retval.length()) // Is an IP address or other special origin. |
70 // string comparison works to order hosts by registry controlled domain | 85 return host; |
71 // first. Leading dots are ignored, ".google.com" is the same as | |
72 // "google.com". | |
73 | 86 |
74 std::string retval = net::RegistryControlledDomainService:: | 87 std::string::size_type position = host.rfind(retval); |
75 GetDomainAndRegistry(host); | |
76 if (!retval.length()) // Is an IP address or other special origin. | |
77 return host; | |
78 | 88 |
79 std::string::size_type position = host.rfind(retval); | 89 // The host may be the registry controlled domain, in which case fail fast. |
| 90 if (position == 0 || position == std::string::npos) |
| 91 return host; |
80 | 92 |
81 // The host may be the registry controlled domain, in which case fail fast. | 93 // If host is www.google.com, retval will contain google.com at this point. |
82 if (position == 0 || position == std::string::npos) | 94 // Start operating to the left of the registry controlled domain, e.g. in |
83 return host; | 95 // the www.google.com example, start at index 3. |
| 96 --position; |
84 | 97 |
85 // If host is www.google.com, retval will contain google.com at this point. | 98 // If position == 0, that means it's a dot; this will be ignored to treat |
86 // Start operating to the left of the registry controlled domain, e.g. in | 99 // ".google.com" the same as "google.com". |
87 // the www.google.com example, start at index 3. | 100 while (position > 0) { |
88 --position; | 101 retval += std::string("."); |
| 102 // Copy up to the next dot. host[position] is a dot so start after it. |
| 103 std::string::size_type next_dot = host.rfind(".", position - 1); |
| 104 if (next_dot == std::string::npos) { |
| 105 retval += host.substr(0, position); |
| 106 break; |
| 107 } |
| 108 retval += host.substr(next_dot + 1, position - (next_dot + 1)); |
| 109 position = next_dot; |
| 110 } |
| 111 return retval; |
| 112 } |
89 | 113 |
90 // If position == 0, that means it's a dot; this will be ignored to treat | 114 bool TypeIsProtected(CookieTreeNode::DetailedInfo::NodeType type) { |
91 // ".google.com" the same as "google.com". | 115 switch (type) { |
92 while (position > 0) { | 116 case CookieTreeNode::DetailedInfo::TYPE_COOKIE: |
93 retval += std::string("."); | 117 return false; |
94 // Copy up to the next dot. host[position] is a dot so start after it. | 118 case CookieTreeNode::DetailedInfo::TYPE_DATABASE: |
95 std::string::size_type next_dot = host.rfind(".", position - 1); | 119 return true; |
96 if (next_dot == std::string::npos) { | 120 case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE: |
97 retval += host.substr(0, position); | 121 return true; |
98 break; | 122 case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE: |
99 } | 123 return true; |
100 retval += host.substr(next_dot + 1, position - (next_dot + 1)); | 124 case CookieTreeNode::DetailedInfo::TYPE_APPCACHE: |
101 position = next_dot; | 125 return true; |
102 } | 126 case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB: |
103 return retval; | 127 return true; |
| 128 case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM: |
| 129 return true; |
| 130 case CookieTreeNode::DetailedInfo::TYPE_QUOTA: |
| 131 return true; |
| 132 case CookieTreeNode::DetailedInfo::TYPE_SERVER_BOUND_CERT: |
| 133 return false; |
| 134 default: |
| 135 break; |
104 } | 136 } |
105 }; | 137 return false; |
| 138 } |
106 | 139 |
107 // This function returns the local data container associated with a leaf tree | 140 // This function returns the local data container associated with a leaf tree |
108 // node. The app node is assumed to be 3 levels above the leaf because of the | 141 // node. The app node is assumed to be 3 levels above the leaf because of the |
109 // following structure: | 142 // following structure: |
110 // root -> origin -> storage type -> leaf node | 143 // root -> origin -> storage type -> leaf node |
111 LocalDataContainer* GetLocalDataContainerForNode(CookieTreeNode* node) { | 144 LocalDataContainer* GetLocalDataContainerForNode(CookieTreeNode* node) { |
112 CookieTreeOriginNode* origin = static_cast<CookieTreeOriginNode*>( | 145 CookieTreeHostNode* host = static_cast<CookieTreeHostNode*>( |
113 node->parent()->parent()); | 146 node->parent()->parent()); |
114 CHECK_EQ(origin->GetDetailedInfo().node_type, | 147 CHECK_EQ(host->GetDetailedInfo().node_type, |
115 CookieTreeNode::DetailedInfo::TYPE_ORIGIN); | 148 CookieTreeNode::DetailedInfo::TYPE_HOST); |
116 return node->GetModel()->GetLocalDataContainer(origin->app_id()); | 149 return node->GetModel()->GetLocalDataContainer(host->app_id()); |
117 } | 150 } |
118 | 151 |
| 152 } // namespace |
119 | 153 |
120 } // namespace | 154 CookieTreeNode::DetailedInfo::DetailedInfo() |
| 155 : node_type(TYPE_NONE), |
| 156 cookie(NULL), |
| 157 database_info(NULL), |
| 158 local_storage_info(NULL), |
| 159 session_storage_info(NULL), |
| 160 appcache_info(NULL), |
| 161 indexed_db_info(NULL), |
| 162 file_system_info(NULL), |
| 163 quota_info(NULL), |
| 164 server_bound_cert(NULL) {} |
| 165 |
| 166 CookieTreeNode::DetailedInfo::~DetailedInfo() {} |
| 167 |
| 168 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::Init( |
| 169 NodeType type) { |
| 170 DCHECK_EQ(TYPE_NONE, node_type); |
| 171 node_type = type; |
| 172 return *this; |
| 173 } |
| 174 |
| 175 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitHost( |
| 176 const std::string& app_id, |
| 177 const std::string& app_name) { |
| 178 Init(TYPE_HOST); |
| 179 this->app_name = app_name; |
| 180 this->app_id = app_id; |
| 181 return *this; |
| 182 } |
| 183 |
| 184 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitCookie( |
| 185 const net::CookieMonster::CanonicalCookie* cookie) { |
| 186 Init(TYPE_COOKIE); |
| 187 this->cookie = cookie; |
| 188 return *this; |
| 189 } |
| 190 |
| 191 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitDatabase( |
| 192 const BrowsingDataDatabaseHelper::DatabaseInfo* database_info) { |
| 193 Init(TYPE_DATABASE); |
| 194 this->database_info = database_info; |
| 195 origin = GURL(database_info->origin); |
| 196 return *this; |
| 197 } |
| 198 |
| 199 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitLocalStorage( |
| 200 const BrowsingDataLocalStorageHelper::LocalStorageInfo* |
| 201 local_storage_info) { |
| 202 Init(TYPE_LOCAL_STORAGE); |
| 203 this->local_storage_info = local_storage_info; |
| 204 origin = local_storage_info->origin_url; |
| 205 return *this; |
| 206 } |
| 207 |
| 208 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitSessionStorage( |
| 209 const BrowsingDataLocalStorageHelper::LocalStorageInfo* |
| 210 session_storage_info) { |
| 211 Init(TYPE_SESSION_STORAGE); |
| 212 this->session_storage_info = session_storage_info; |
| 213 origin = session_storage_info->origin_url; |
| 214 return *this; |
| 215 } |
| 216 |
| 217 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitAppCache( |
| 218 const GURL& origin, |
| 219 const appcache::AppCacheInfo* appcache_info) { |
| 220 Init(TYPE_APPCACHE); |
| 221 this->appcache_info = appcache_info; |
| 222 this->origin = origin; |
| 223 return *this; |
| 224 } |
| 225 |
| 226 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitIndexedDB( |
| 227 const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info) { |
| 228 Init(TYPE_INDEXED_DB); |
| 229 this->indexed_db_info = indexed_db_info; |
| 230 this->origin = indexed_db_info->origin; |
| 231 return *this; |
| 232 } |
| 233 |
| 234 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitFileSystem( |
| 235 const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info) { |
| 236 Init(TYPE_FILE_SYSTEM); |
| 237 this->file_system_info = file_system_info; |
| 238 this->origin = file_system_info->origin; |
| 239 return *this; |
| 240 } |
| 241 |
| 242 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitQuota( |
| 243 const BrowsingDataQuotaHelper::QuotaInfo* quota_info) { |
| 244 Init(TYPE_QUOTA); |
| 245 this->quota_info = quota_info; |
| 246 return *this; |
| 247 } |
| 248 |
| 249 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitServerBoundCert( |
| 250 const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert) { |
| 251 Init(TYPE_SERVER_BOUND_CERT); |
| 252 this->server_bound_cert = server_bound_cert; |
| 253 return *this; |
| 254 } |
121 | 255 |
122 /////////////////////////////////////////////////////////////////////////////// | 256 /////////////////////////////////////////////////////////////////////////////// |
123 // CookieTreeNode, public: | 257 // CookieTreeNode, public: |
124 | 258 |
125 void CookieTreeNode::DeleteStoredObjects() { | 259 void CookieTreeNode::DeleteStoredObjects() { |
126 std::for_each(children().begin(), | 260 std::for_each(children().begin(), |
127 children().end(), | 261 children().end(), |
128 std::mem_fun(&CookieTreeNode::DeleteStoredObjects)); | 262 std::mem_fun(&CookieTreeNode::DeleteStoredObjects)); |
129 } | 263 } |
130 | 264 |
(...skipping 16 matching lines...) Expand all Loading... |
147 CookieTreeCookieNode::~CookieTreeCookieNode() {} | 281 CookieTreeCookieNode::~CookieTreeCookieNode() {} |
148 | 282 |
149 void CookieTreeCookieNode::DeleteStoredObjects() { | 283 void CookieTreeCookieNode::DeleteStoredObjects() { |
150 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 284 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
151 CHECK(container); | 285 CHECK(container); |
152 container->cookie_helper_->DeleteCookie(*cookie_); | 286 container->cookie_helper_->DeleteCookie(*cookie_); |
153 container->cookie_list_.erase(cookie_); | 287 container->cookie_list_.erase(cookie_); |
154 } | 288 } |
155 | 289 |
156 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const { | 290 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const { |
157 return DetailedInfo(parent()->parent()->GetTitle()).InitCookie(&*cookie_); | 291 return DetailedInfo().InitCookie(&*cookie_); |
158 } | 292 } |
159 | 293 |
160 /////////////////////////////////////////////////////////////////////////////// | 294 /////////////////////////////////////////////////////////////////////////////// |
161 // CookieTreeAppCacheNode, public: | 295 // CookieTreeAppCacheNode, public: |
162 | 296 |
163 CookieTreeAppCacheNode::CookieTreeAppCacheNode( | 297 CookieTreeAppCacheNode::CookieTreeAppCacheNode( |
164 const GURL& origin_url, | 298 const GURL& origin_url, |
165 std::list<appcache::AppCacheInfo>::iterator appcache_info) | 299 std::list<appcache::AppCacheInfo>::iterator appcache_info) |
166 : CookieTreeNode(UTF8ToUTF16(appcache_info->manifest_url.spec())), | 300 : CookieTreeNode(UTF8ToUTF16(appcache_info->manifest_url.spec())), |
167 origin_url_(origin_url), | 301 origin_url_(origin_url), |
168 appcache_info_(appcache_info) { | 302 appcache_info_(appcache_info) { |
169 } | 303 } |
170 | 304 |
171 CookieTreeAppCacheNode::~CookieTreeAppCacheNode() { | 305 CookieTreeAppCacheNode::~CookieTreeAppCacheNode() { |
172 } | 306 } |
173 | 307 |
174 void CookieTreeAppCacheNode::DeleteStoredObjects() { | 308 void CookieTreeAppCacheNode::DeleteStoredObjects() { |
175 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 309 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
176 | 310 |
177 if (container) { | 311 if (container) { |
178 DCHECK(container->appcache_helper_); | 312 DCHECK(container->appcache_helper_); |
179 container->appcache_helper_->DeleteAppCacheGroup( | 313 container->appcache_helper_->DeleteAppCacheGroup( |
180 appcache_info_->manifest_url); | 314 appcache_info_->manifest_url); |
181 container->appcache_info_[origin_url_].erase(appcache_info_); | 315 container->appcache_info_[origin_url_].erase(appcache_info_); |
182 } | 316 } |
183 } | 317 } |
184 | 318 |
185 CookieTreeNode::DetailedInfo CookieTreeAppCacheNode::GetDetailedInfo() const { | 319 CookieTreeNode::DetailedInfo CookieTreeAppCacheNode::GetDetailedInfo() const { |
186 return DetailedInfo(parent()->parent()->GetTitle()).InitAppCache( | 320 return DetailedInfo().InitAppCache(origin_url_, &*appcache_info_); |
187 &*appcache_info_); | |
188 } | 321 } |
189 | 322 |
190 /////////////////////////////////////////////////////////////////////////////// | 323 /////////////////////////////////////////////////////////////////////////////// |
191 // CookieTreeDatabaseNode, public: | 324 // CookieTreeDatabaseNode, public: |
192 | 325 |
193 CookieTreeDatabaseNode::CookieTreeDatabaseNode( | 326 CookieTreeDatabaseNode::CookieTreeDatabaseNode( |
194 std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator database_info) | 327 std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator database_info) |
195 : CookieTreeNode(database_info->database_name.empty() ? | 328 : CookieTreeNode(database_info->database_name.empty() ? |
196 l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME) : | 329 l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME) : |
197 UTF8ToUTF16(database_info->database_name)), | 330 UTF8ToUTF16(database_info->database_name)), |
198 database_info_(database_info) { | 331 database_info_(database_info) { |
199 } | 332 } |
200 | 333 |
201 CookieTreeDatabaseNode::~CookieTreeDatabaseNode() {} | 334 CookieTreeDatabaseNode::~CookieTreeDatabaseNode() {} |
202 | 335 |
203 void CookieTreeDatabaseNode::DeleteStoredObjects() { | 336 void CookieTreeDatabaseNode::DeleteStoredObjects() { |
204 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 337 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
205 | 338 |
206 if (container) { | 339 if (container) { |
207 container->database_helper_->DeleteDatabase( | 340 container->database_helper_->DeleteDatabase( |
208 database_info_->origin_identifier, database_info_->database_name); | 341 database_info_->origin_identifier, database_info_->database_name); |
209 container->database_info_list_.erase(database_info_); | 342 container->database_info_list_.erase(database_info_); |
210 } | 343 } |
211 } | 344 } |
212 | 345 |
213 CookieTreeNode::DetailedInfo CookieTreeDatabaseNode::GetDetailedInfo() const { | 346 CookieTreeNode::DetailedInfo CookieTreeDatabaseNode::GetDetailedInfo() const { |
214 return DetailedInfo(parent()->parent()->GetTitle()).InitDatabase( | 347 return DetailedInfo().InitDatabase(&*database_info_); |
215 &*database_info_); | |
216 } | 348 } |
217 | 349 |
218 /////////////////////////////////////////////////////////////////////////////// | 350 /////////////////////////////////////////////////////////////////////////////// |
219 // CookieTreeLocalStorageNode, public: | 351 // CookieTreeLocalStorageNode, public: |
220 | 352 |
221 CookieTreeLocalStorageNode::CookieTreeLocalStorageNode( | 353 CookieTreeLocalStorageNode::CookieTreeLocalStorageNode( |
222 std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator | 354 std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator |
223 local_storage_info) | 355 local_storage_info) |
224 : CookieTreeNode(UTF8ToUTF16(local_storage_info->origin_url.spec())), | 356 : CookieTreeNode(UTF8ToUTF16(local_storage_info->origin_url.spec())), |
225 local_storage_info_(local_storage_info) { | 357 local_storage_info_(local_storage_info) { |
226 } | 358 } |
227 | 359 |
228 CookieTreeLocalStorageNode::~CookieTreeLocalStorageNode() {} | 360 CookieTreeLocalStorageNode::~CookieTreeLocalStorageNode() {} |
229 | 361 |
230 void CookieTreeLocalStorageNode::DeleteStoredObjects() { | 362 void CookieTreeLocalStorageNode::DeleteStoredObjects() { |
231 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 363 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
232 | 364 |
233 if (container) { | 365 if (container) { |
234 container->local_storage_helper_->DeleteOrigin( | 366 container->local_storage_helper_->DeleteOrigin( |
235 local_storage_info_->origin_url); | 367 local_storage_info_->origin_url); |
236 container->local_storage_info_list_.erase(local_storage_info_); | 368 container->local_storage_info_list_.erase(local_storage_info_); |
237 } | 369 } |
238 } | 370 } |
239 | 371 |
240 CookieTreeNode::DetailedInfo | 372 CookieTreeNode::DetailedInfo |
241 CookieTreeLocalStorageNode::GetDetailedInfo() const { | 373 CookieTreeLocalStorageNode::GetDetailedInfo() const { |
242 return DetailedInfo(parent()->parent()->GetTitle()).InitLocalStorage( | 374 return DetailedInfo().InitLocalStorage( |
243 &*local_storage_info_); | 375 &*local_storage_info_); |
244 } | 376 } |
245 | 377 |
246 /////////////////////////////////////////////////////////////////////////////// | 378 /////////////////////////////////////////////////////////////////////////////// |
247 // CookieTreeSessionStorageNode, public: | 379 // CookieTreeSessionStorageNode, public: |
248 | 380 |
249 CookieTreeSessionStorageNode::CookieTreeSessionStorageNode( | 381 CookieTreeSessionStorageNode::CookieTreeSessionStorageNode( |
250 std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator | 382 std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator |
251 session_storage_info) | 383 session_storage_info) |
252 : CookieTreeNode(UTF8ToUTF16(session_storage_info->origin_url.spec())), | 384 : CookieTreeNode(UTF8ToUTF16(session_storage_info->origin_url.spec())), |
253 session_storage_info_(session_storage_info) { | 385 session_storage_info_(session_storage_info) { |
254 } | 386 } |
255 | 387 |
256 CookieTreeSessionStorageNode::~CookieTreeSessionStorageNode() {} | 388 CookieTreeSessionStorageNode::~CookieTreeSessionStorageNode() {} |
257 | 389 |
258 void CookieTreeSessionStorageNode::DeleteStoredObjects() { | 390 void CookieTreeSessionStorageNode::DeleteStoredObjects() { |
259 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 391 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
260 | 392 |
261 if (container) { | 393 if (container) { |
262 container->session_storage_info_list_.erase(session_storage_info_); | 394 container->session_storage_info_list_.erase(session_storage_info_); |
263 } | 395 } |
264 } | 396 } |
265 | 397 |
266 CookieTreeNode::DetailedInfo | 398 CookieTreeNode::DetailedInfo |
267 CookieTreeSessionStorageNode::GetDetailedInfo() const { | 399 CookieTreeSessionStorageNode::GetDetailedInfo() const { |
268 return DetailedInfo(parent()->parent()->GetTitle()).InitSessionStorage( | 400 return DetailedInfo().InitSessionStorage(&*session_storage_info_); |
269 &*session_storage_info_); | |
270 } | 401 } |
271 | 402 |
272 /////////////////////////////////////////////////////////////////////////////// | 403 /////////////////////////////////////////////////////////////////////////////// |
273 // CookieTreeIndexedDBNode, public: | 404 // CookieTreeIndexedDBNode, public: |
274 | 405 |
275 CookieTreeIndexedDBNode::CookieTreeIndexedDBNode( | 406 CookieTreeIndexedDBNode::CookieTreeIndexedDBNode( |
276 std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>::iterator | 407 std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>::iterator |
277 indexed_db_info) | 408 indexed_db_info) |
278 : CookieTreeNode(UTF8ToUTF16( | 409 : CookieTreeNode(UTF8ToUTF16( |
279 indexed_db_info->origin.spec())), | 410 indexed_db_info->origin.spec())), |
280 indexed_db_info_(indexed_db_info) { | 411 indexed_db_info_(indexed_db_info) { |
281 } | 412 } |
282 | 413 |
283 CookieTreeIndexedDBNode::~CookieTreeIndexedDBNode() {} | 414 CookieTreeIndexedDBNode::~CookieTreeIndexedDBNode() {} |
284 | 415 |
285 void CookieTreeIndexedDBNode::DeleteStoredObjects() { | 416 void CookieTreeIndexedDBNode::DeleteStoredObjects() { |
286 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 417 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
287 | 418 |
288 if (container) { | 419 if (container) { |
289 container->indexed_db_helper_->DeleteIndexedDB( | 420 container->indexed_db_helper_->DeleteIndexedDB( |
290 indexed_db_info_->origin); | 421 indexed_db_info_->origin); |
291 container->indexed_db_info_list_.erase(indexed_db_info_); | 422 container->indexed_db_info_list_.erase(indexed_db_info_); |
292 } | 423 } |
293 } | 424 } |
294 | 425 |
295 CookieTreeNode::DetailedInfo CookieTreeIndexedDBNode::GetDetailedInfo() const { | 426 CookieTreeNode::DetailedInfo CookieTreeIndexedDBNode::GetDetailedInfo() const { |
296 return DetailedInfo(parent()->parent()->GetTitle()).InitIndexedDB( | 427 return DetailedInfo().InitIndexedDB(&*indexed_db_info_); |
297 &*indexed_db_info_); | |
298 } | 428 } |
299 | 429 |
300 /////////////////////////////////////////////////////////////////////////////// | 430 /////////////////////////////////////////////////////////////////////////////// |
301 // CookieTreeFileSystemNode, public: | 431 // CookieTreeFileSystemNode, public: |
302 | 432 |
303 CookieTreeFileSystemNode::CookieTreeFileSystemNode( | 433 CookieTreeFileSystemNode::CookieTreeFileSystemNode( |
304 std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator | 434 std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator |
305 file_system_info) | 435 file_system_info) |
306 : CookieTreeNode(UTF8ToUTF16( | 436 : CookieTreeNode(UTF8ToUTF16( |
307 file_system_info->origin.spec())), | 437 file_system_info->origin.spec())), |
308 file_system_info_(file_system_info) { | 438 file_system_info_(file_system_info) { |
309 } | 439 } |
310 | 440 |
311 CookieTreeFileSystemNode::~CookieTreeFileSystemNode() {} | 441 CookieTreeFileSystemNode::~CookieTreeFileSystemNode() {} |
312 | 442 |
313 void CookieTreeFileSystemNode::DeleteStoredObjects() { | 443 void CookieTreeFileSystemNode::DeleteStoredObjects() { |
314 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 444 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
315 | 445 |
316 if (container) { | 446 if (container) { |
317 container->file_system_helper_->DeleteFileSystemOrigin( | 447 container->file_system_helper_->DeleteFileSystemOrigin( |
318 file_system_info_->origin); | 448 file_system_info_->origin); |
319 container->file_system_info_list_.erase(file_system_info_); | 449 container->file_system_info_list_.erase(file_system_info_); |
320 } | 450 } |
321 } | 451 } |
322 | 452 |
323 CookieTreeNode::DetailedInfo CookieTreeFileSystemNode::GetDetailedInfo() const { | 453 CookieTreeNode::DetailedInfo CookieTreeFileSystemNode::GetDetailedInfo() const { |
324 return DetailedInfo(parent()->parent()->GetTitle()).InitFileSystem( | 454 return DetailedInfo().InitFileSystem(&*file_system_info_); |
325 &*file_system_info_); | |
326 } | 455 } |
327 | 456 |
328 /////////////////////////////////////////////////////////////////////////////// | 457 /////////////////////////////////////////////////////////////////////////////// |
329 // CookieTreeQuotaNode, public: | 458 // CookieTreeQuotaNode, public: |
330 | 459 |
331 CookieTreeQuotaNode::CookieTreeQuotaNode( | 460 CookieTreeQuotaNode::CookieTreeQuotaNode( |
332 std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) | 461 std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) |
333 : CookieTreeNode(UTF8ToUTF16(quota_info->host)), | 462 : CookieTreeNode(UTF8ToUTF16(quota_info->host)), |
334 quota_info_(quota_info) { | 463 quota_info_(quota_info) { |
335 } | 464 } |
336 | 465 |
337 CookieTreeQuotaNode::~CookieTreeQuotaNode() {} | 466 CookieTreeQuotaNode::~CookieTreeQuotaNode() {} |
338 | 467 |
339 void CookieTreeQuotaNode::DeleteStoredObjects() { | 468 void CookieTreeQuotaNode::DeleteStoredObjects() { |
340 // Calling this function may cause unexpected over-quota state of origin. | 469 // Calling this function may cause unexpected over-quota state of origin. |
341 // However, it'll caused no problem, just prevent usage growth of the origin. | 470 // However, it'll caused no problem, just prevent usage growth of the origin. |
342 CookieTreeOriginNode* app = static_cast<CookieTreeOriginNode*>(parent()); | 471 CookieTreeHostNode* app = static_cast<CookieTreeHostNode*>(parent()); |
343 LocalDataContainer* container = GetModel()->GetLocalDataContainer( | 472 LocalDataContainer* container = GetModel()->GetLocalDataContainer( |
344 app->app_id()); | 473 app->app_id()); |
345 | 474 |
346 if (container) { | 475 if (container) { |
347 container->quota_helper_->RevokeHostQuota(quota_info_->host); | 476 container->quota_helper_->RevokeHostQuota(quota_info_->host); |
348 container->quota_info_list_.erase(quota_info_); | 477 container->quota_info_list_.erase(quota_info_); |
349 } | 478 } |
350 } | 479 } |
351 | 480 |
352 CookieTreeNode::DetailedInfo CookieTreeQuotaNode::GetDetailedInfo() const { | 481 CookieTreeNode::DetailedInfo CookieTreeQuotaNode::GetDetailedInfo() const { |
353 return DetailedInfo(parent()->parent()->GetTitle()).InitQuota( | 482 return DetailedInfo().InitQuota(&*quota_info_); |
354 &*quota_info_); | |
355 } | 483 } |
356 | 484 |
357 /////////////////////////////////////////////////////////////////////////////// | 485 /////////////////////////////////////////////////////////////////////////////// |
358 // CookieTreeServerBoundCertNode, public: | 486 // CookieTreeServerBoundCertNode, public: |
359 | 487 |
360 CookieTreeServerBoundCertNode::CookieTreeServerBoundCertNode( | 488 CookieTreeServerBoundCertNode::CookieTreeServerBoundCertNode( |
361 net::ServerBoundCertStore::ServerBoundCertList::iterator cert) | 489 net::ServerBoundCertStore::ServerBoundCertList::iterator cert) |
362 : CookieTreeNode(ASCIIToUTF16(cert->server_identifier())), | 490 : CookieTreeNode(ASCIIToUTF16(cert->server_identifier())), |
363 server_bound_cert_(cert) { | 491 server_bound_cert_(cert) { |
364 } | 492 } |
365 | 493 |
366 CookieTreeServerBoundCertNode::~CookieTreeServerBoundCertNode() {} | 494 CookieTreeServerBoundCertNode::~CookieTreeServerBoundCertNode() {} |
367 | 495 |
368 void CookieTreeServerBoundCertNode::DeleteStoredObjects() { | 496 void CookieTreeServerBoundCertNode::DeleteStoredObjects() { |
369 LocalDataContainer* container = GetLocalDataContainerForNode(this); | 497 LocalDataContainer* container = GetLocalDataContainerForNode(this); |
370 | 498 |
371 if (container) { | 499 if (container) { |
372 container->server_bound_cert_helper_->DeleteServerBoundCert( | 500 container->server_bound_cert_helper_->DeleteServerBoundCert( |
373 server_bound_cert_->server_identifier()); | 501 server_bound_cert_->server_identifier()); |
374 container->server_bound_cert_list_.erase(server_bound_cert_); | 502 container->server_bound_cert_list_.erase(server_bound_cert_); |
375 } | 503 } |
376 } | 504 } |
377 | 505 |
378 CookieTreeNode::DetailedInfo | 506 CookieTreeNode::DetailedInfo |
379 CookieTreeServerBoundCertNode::GetDetailedInfo() const { | 507 CookieTreeServerBoundCertNode::GetDetailedInfo() const { |
380 return DetailedInfo(parent()->parent()->GetTitle()).InitServerBoundCert( | 508 return DetailedInfo().InitServerBoundCert(&*server_bound_cert_); |
381 &*server_bound_cert_); | |
382 } | 509 } |
383 | 510 |
384 /////////////////////////////////////////////////////////////////////////////// | 511 /////////////////////////////////////////////////////////////////////////////// |
385 // CookieTreeRootNode, public: | 512 // CookieTreeRootNode, public: |
386 | 513 |
387 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model) | 514 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model) |
388 : model_(model) { | 515 : model_(model) { |
389 } | 516 } |
390 | 517 |
391 CookieTreeRootNode::~CookieTreeRootNode() {} | 518 CookieTreeRootNode::~CookieTreeRootNode() {} |
392 | 519 |
393 CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode( | 520 CookieTreeHostNode* CookieTreeRootNode::GetOrCreateHostNode( |
394 const GURL& url, | 521 const GURL& url, |
395 const std::string& app_id, | 522 const std::string& app_id, |
396 const std::string& app_name) { | 523 const std::string& app_name) { |
397 CookieTreeOriginNode origin_node(url, app_id, app_name); | 524 scoped_ptr<CookieTreeHostNode> host_node( |
| 525 new CookieTreeHostNode(url, app_id, app_name)); |
398 | 526 |
399 // First see if there is an existing match. | 527 // First see if there is an existing match. |
400 std::vector<CookieTreeNode*>::iterator origin_node_iterator = | 528 std::vector<CookieTreeNode*>::iterator host_node_iterator = |
401 std::lower_bound(children().begin(), children().end(), &origin_node, | 529 std::lower_bound(children().begin(), children().end(), host_node.get(), |
402 OriginNodeComparator()); | 530 HostNodeComparator()); |
403 if (origin_node_iterator != children().end() && | 531 if (host_node_iterator != children().end() && |
404 CookieTreeOriginNode::TitleForUrl(url, app_id, app_name) == | 532 CookieTreeHostNode::TitleForUrl(url, app_id, app_name) == |
405 (*origin_node_iterator)->GetTitle()) | 533 (*host_node_iterator)->GetTitle()) |
406 return static_cast<CookieTreeOriginNode*>(*origin_node_iterator); | 534 return static_cast<CookieTreeHostNode*>(*host_node_iterator); |
407 // Node doesn't exist, create a new one and insert it into the (ordered) | 535 // Node doesn't exist, insert the new one into the (ordered) children. |
408 // children. | |
409 CookieTreeOriginNode* retval = new CookieTreeOriginNode(url, app_id, | |
410 app_name); | |
411 DCHECK(model_); | 536 DCHECK(model_); |
412 model_->Add(this, retval, (origin_node_iterator - children().begin())); | 537 model_->Add(this, host_node.get(), |
413 return retval; | 538 (host_node_iterator - children().begin())); |
| 539 return host_node.release(); |
414 } | 540 } |
415 | 541 |
416 CookiesTreeModel* CookieTreeRootNode::GetModel() const { | 542 CookiesTreeModel* CookieTreeRootNode::GetModel() const { |
417 return model_; | 543 return model_; |
418 } | 544 } |
419 | 545 |
420 CookieTreeNode::DetailedInfo CookieTreeRootNode::GetDetailedInfo() const { | 546 CookieTreeNode::DetailedInfo CookieTreeRootNode::GetDetailedInfo() const { |
421 return DetailedInfo(string16()).Init(DetailedInfo::TYPE_ROOT); | 547 return DetailedInfo().Init(DetailedInfo::TYPE_ROOT); |
422 } | 548 } |
423 | 549 |
424 /////////////////////////////////////////////////////////////////////////////// | 550 /////////////////////////////////////////////////////////////////////////////// |
425 // CookieTreeOriginNode, public: | 551 // CookieTreeHostNode, public: |
426 | 552 |
427 // static | 553 // static |
428 string16 CookieTreeOriginNode::TitleForUrl( | 554 string16 CookieTreeHostNode::TitleForUrl( |
429 const GURL& url, | 555 const GURL& url, |
430 const std::string& app_id, | 556 const std::string& app_id, |
431 const std::string& app_name) { | 557 const std::string& app_name) { |
432 std::string title; | 558 std::string title; |
433 const std::string file_origin_node_name( | 559 const std::string file_origin_node_name( |
434 std::string(chrome::kFileScheme) + content::kStandardSchemeSeparator); | 560 std::string(chrome::kFileScheme) + content::kStandardSchemeSeparator); |
435 // Only prepend the app name, if the app id is not an empty string. | 561 // Only prepend the app name, if the app id is not an empty string. |
436 if (!app_id.empty()) { | 562 if (!app_id.empty()) { |
437 title = app_name; | 563 title = app_name; |
438 title.append(", "); | 564 title.append(", "); |
439 } | 565 } |
440 title.append(url.SchemeIsFile() ? file_origin_node_name : url.host()); | 566 title.append(url.SchemeIsFile() ? file_origin_node_name : url.host()); |
441 return UTF8ToUTF16(title); | 567 return UTF8ToUTF16(title); |
442 } | 568 } |
443 | 569 |
444 CookieTreeOriginNode::CookieTreeOriginNode(const GURL& url, | 570 CookieTreeHostNode::CookieTreeHostNode(const GURL& url, |
445 const std::string& app_id, | 571 const std::string& app_id, |
446 const std::string& name) | 572 const std::string& name) |
447 : CookieTreeNode(TitleForUrl(url, app_id, name)), | 573 : CookieTreeNode(TitleForUrl(url, app_id, name)), |
448 cookies_child_(NULL), | 574 cookies_child_(NULL), |
449 databases_child_(NULL), | 575 databases_child_(NULL), |
450 local_storages_child_(NULL), | 576 local_storages_child_(NULL), |
451 session_storages_child_(NULL), | 577 session_storages_child_(NULL), |
452 appcaches_child_(NULL), | 578 appcaches_child_(NULL), |
453 indexed_dbs_child_(NULL), | 579 indexed_dbs_child_(NULL), |
454 file_systems_child_(NULL), | 580 file_systems_child_(NULL), |
455 quota_child_(NULL), | 581 quota_child_(NULL), |
456 server_bound_certs_child_(NULL), | 582 server_bound_certs_child_(NULL), |
457 app_id_(app_id), | 583 app_id_(app_id), |
458 app_name_(name), | 584 app_name_(name), |
459 url_(url) {} | 585 url_(url), |
| 586 canonicalized_host_(CanonicalizeHost(url)) {} |
460 | 587 |
461 CookieTreeOriginNode::~CookieTreeOriginNode() {} | 588 CookieTreeHostNode::~CookieTreeHostNode() {} |
462 | 589 |
463 const std::string CookieTreeOriginNode::GetHost() const { | 590 const std::string CookieTreeHostNode::GetHost() const { |
464 const std::string file_origin_node_name( | 591 const std::string file_origin_node_name( |
465 std::string(chrome::kFileScheme) + content::kStandardSchemeSeparator); | 592 std::string(chrome::kFileScheme) + content::kStandardSchemeSeparator); |
466 return url_.SchemeIsFile() ? file_origin_node_name : url_.host(); | 593 return url_.SchemeIsFile() ? file_origin_node_name : url_.host(); |
467 } | 594 } |
468 | 595 |
469 CookieTreeNode::DetailedInfo CookieTreeOriginNode::GetDetailedInfo() const { | 596 CookieTreeNode::DetailedInfo CookieTreeHostNode::GetDetailedInfo() const { |
470 return DetailedInfo(GetTitle()).InitOrigin(app_id_, app_name_); | 597 return DetailedInfo().InitHost(app_id_, app_name_); |
471 } | 598 } |
472 | 599 |
473 CookieTreeCookiesNode* CookieTreeOriginNode::GetOrCreateCookiesNode() { | 600 CookieTreeCookiesNode* CookieTreeHostNode::GetOrCreateCookiesNode() { |
474 if (cookies_child_) | 601 if (cookies_child_) |
475 return cookies_child_; | 602 return cookies_child_; |
476 cookies_child_ = new CookieTreeCookiesNode; | 603 cookies_child_ = new CookieTreeCookiesNode; |
477 AddChildSortedByTitle(cookies_child_); | 604 AddChildSortedByTitle(cookies_child_); |
478 return cookies_child_; | 605 return cookies_child_; |
479 } | 606 } |
480 | 607 |
481 CookieTreeDatabasesNode* CookieTreeOriginNode::GetOrCreateDatabasesNode() { | 608 CookieTreeDatabasesNode* CookieTreeHostNode::GetOrCreateDatabasesNode() { |
482 if (databases_child_) | 609 if (databases_child_) |
483 return databases_child_; | 610 return databases_child_; |
484 databases_child_ = new CookieTreeDatabasesNode; | 611 databases_child_ = new CookieTreeDatabasesNode; |
485 AddChildSortedByTitle(databases_child_); | 612 AddChildSortedByTitle(databases_child_); |
486 return databases_child_; | 613 return databases_child_; |
487 } | 614 } |
488 | 615 |
489 CookieTreeLocalStoragesNode* | 616 CookieTreeLocalStoragesNode* |
490 CookieTreeOriginNode::GetOrCreateLocalStoragesNode() { | 617 CookieTreeHostNode::GetOrCreateLocalStoragesNode() { |
491 if (local_storages_child_) | 618 if (local_storages_child_) |
492 return local_storages_child_; | 619 return local_storages_child_; |
493 local_storages_child_ = new CookieTreeLocalStoragesNode; | 620 local_storages_child_ = new CookieTreeLocalStoragesNode; |
494 AddChildSortedByTitle(local_storages_child_); | 621 AddChildSortedByTitle(local_storages_child_); |
495 return local_storages_child_; | 622 return local_storages_child_; |
496 } | 623 } |
497 | 624 |
498 CookieTreeSessionStoragesNode* | 625 CookieTreeSessionStoragesNode* |
499 CookieTreeOriginNode::GetOrCreateSessionStoragesNode() { | 626 CookieTreeHostNode::GetOrCreateSessionStoragesNode() { |
500 if (session_storages_child_) | 627 if (session_storages_child_) |
501 return session_storages_child_; | 628 return session_storages_child_; |
502 session_storages_child_ = new CookieTreeSessionStoragesNode; | 629 session_storages_child_ = new CookieTreeSessionStoragesNode; |
503 AddChildSortedByTitle(session_storages_child_); | 630 AddChildSortedByTitle(session_storages_child_); |
504 return session_storages_child_; | 631 return session_storages_child_; |
505 } | 632 } |
506 | 633 |
507 CookieTreeAppCachesNode* CookieTreeOriginNode::GetOrCreateAppCachesNode() { | 634 CookieTreeAppCachesNode* CookieTreeHostNode::GetOrCreateAppCachesNode() { |
508 if (appcaches_child_) | 635 if (appcaches_child_) |
509 return appcaches_child_; | 636 return appcaches_child_; |
510 appcaches_child_ = new CookieTreeAppCachesNode; | 637 appcaches_child_ = new CookieTreeAppCachesNode; |
511 AddChildSortedByTitle(appcaches_child_); | 638 AddChildSortedByTitle(appcaches_child_); |
512 return appcaches_child_; | 639 return appcaches_child_; |
513 } | 640 } |
514 | 641 |
515 CookieTreeIndexedDBsNode* CookieTreeOriginNode::GetOrCreateIndexedDBsNode() { | 642 CookieTreeIndexedDBsNode* CookieTreeHostNode::GetOrCreateIndexedDBsNode() { |
516 if (indexed_dbs_child_) | 643 if (indexed_dbs_child_) |
517 return indexed_dbs_child_; | 644 return indexed_dbs_child_; |
518 indexed_dbs_child_ = new CookieTreeIndexedDBsNode; | 645 indexed_dbs_child_ = new CookieTreeIndexedDBsNode; |
519 AddChildSortedByTitle(indexed_dbs_child_); | 646 AddChildSortedByTitle(indexed_dbs_child_); |
520 return indexed_dbs_child_; | 647 return indexed_dbs_child_; |
521 } | 648 } |
522 | 649 |
523 CookieTreeFileSystemsNode* CookieTreeOriginNode::GetOrCreateFileSystemsNode() { | 650 CookieTreeFileSystemsNode* CookieTreeHostNode::GetOrCreateFileSystemsNode() { |
524 if (file_systems_child_) | 651 if (file_systems_child_) |
525 return file_systems_child_; | 652 return file_systems_child_; |
526 file_systems_child_ = new CookieTreeFileSystemsNode; | 653 file_systems_child_ = new CookieTreeFileSystemsNode; |
527 AddChildSortedByTitle(file_systems_child_); | 654 AddChildSortedByTitle(file_systems_child_); |
528 return file_systems_child_; | 655 return file_systems_child_; |
529 } | 656 } |
530 | 657 |
531 CookieTreeQuotaNode* CookieTreeOriginNode::UpdateOrCreateQuotaNode( | 658 CookieTreeQuotaNode* CookieTreeHostNode::UpdateOrCreateQuotaNode( |
532 std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) { | 659 std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) { |
533 if (quota_child_) | 660 if (quota_child_) |
534 return quota_child_; | 661 return quota_child_; |
535 quota_child_ = new CookieTreeQuotaNode(quota_info); | 662 quota_child_ = new CookieTreeQuotaNode(quota_info); |
536 AddChildSortedByTitle(quota_child_); | 663 AddChildSortedByTitle(quota_child_); |
537 return quota_child_; | 664 return quota_child_; |
538 } | 665 } |
539 | 666 |
540 CookieTreeServerBoundCertsNode* | 667 CookieTreeServerBoundCertsNode* |
541 CookieTreeOriginNode::GetOrCreateServerBoundCertsNode() { | 668 CookieTreeHostNode::GetOrCreateServerBoundCertsNode() { |
542 if (server_bound_certs_child_) | 669 if (server_bound_certs_child_) |
543 return server_bound_certs_child_; | 670 return server_bound_certs_child_; |
544 server_bound_certs_child_ = new CookieTreeServerBoundCertsNode; | 671 server_bound_certs_child_ = new CookieTreeServerBoundCertsNode; |
545 AddChildSortedByTitle(server_bound_certs_child_); | 672 AddChildSortedByTitle(server_bound_certs_child_); |
546 return server_bound_certs_child_; | 673 return server_bound_certs_child_; |
547 } | 674 } |
548 | 675 |
549 void CookieTreeOriginNode::CreateContentException( | 676 void CookieTreeHostNode::CreateContentException( |
550 CookieSettings* cookie_settings, ContentSetting setting) const { | 677 CookieSettings* cookie_settings, ContentSetting setting) const { |
551 DCHECK(setting == CONTENT_SETTING_ALLOW || | 678 DCHECK(setting == CONTENT_SETTING_ALLOW || |
552 setting == CONTENT_SETTING_BLOCK || | 679 setting == CONTENT_SETTING_BLOCK || |
553 setting == CONTENT_SETTING_SESSION_ONLY); | 680 setting == CONTENT_SETTING_SESSION_ONLY); |
554 if (CanCreateContentException()) { | 681 if (CanCreateContentException()) { |
555 cookie_settings->ResetCookieSetting( | 682 cookie_settings->ResetCookieSetting( |
556 ContentSettingsPattern::FromURLNoWildcard(url_), | 683 ContentSettingsPattern::FromURLNoWildcard(url_), |
557 ContentSettingsPattern::Wildcard()); | 684 ContentSettingsPattern::Wildcard()); |
558 cookie_settings->SetCookieSetting( | 685 cookie_settings->SetCookieSetting( |
559 ContentSettingsPattern::FromURL(url_), | 686 ContentSettingsPattern::FromURL(url_), |
560 ContentSettingsPattern::Wildcard(), setting); | 687 ContentSettingsPattern::Wildcard(), setting); |
561 } | 688 } |
562 } | 689 } |
563 | 690 |
564 bool CookieTreeOriginNode::CanCreateContentException() const { | 691 bool CookieTreeHostNode::CanCreateContentException() const { |
565 return !url_.SchemeIsFile(); | 692 return !url_.SchemeIsFile(); |
566 } | 693 } |
567 | 694 |
568 /////////////////////////////////////////////////////////////////////////////// | 695 /////////////////////////////////////////////////////////////////////////////// |
569 // CookieTreeCookiesNode, public: | 696 // CookieTreeCookiesNode, public: |
570 | 697 |
571 CookieTreeCookiesNode::CookieTreeCookiesNode() | 698 CookieTreeCookiesNode::CookieTreeCookiesNode() |
572 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_COOKIES)) { | 699 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_COOKIES)) { |
573 } | 700 } |
574 | 701 |
575 CookieTreeCookiesNode::~CookieTreeCookiesNode() { | 702 CookieTreeCookiesNode::~CookieTreeCookiesNode() { |
576 } | 703 } |
577 | 704 |
578 CookieTreeNode::DetailedInfo CookieTreeCookiesNode::GetDetailedInfo() const { | 705 CookieTreeNode::DetailedInfo CookieTreeCookiesNode::GetDetailedInfo() const { |
579 return DetailedInfo(parent()->GetTitle()).Init(DetailedInfo::TYPE_COOKIES); | 706 return DetailedInfo().Init(DetailedInfo::TYPE_COOKIES); |
580 } | 707 } |
581 | 708 |
582 /////////////////////////////////////////////////////////////////////////////// | 709 /////////////////////////////////////////////////////////////////////////////// |
583 // CookieTreeAppCachesNode, public: | 710 // CookieTreeAppCachesNode, public: |
584 | 711 |
585 CookieTreeAppCachesNode::CookieTreeAppCachesNode() | 712 CookieTreeAppCachesNode::CookieTreeAppCachesNode() |
586 : CookieTreeNode(l10n_util::GetStringUTF16( | 713 : CookieTreeNode(l10n_util::GetStringUTF16( |
587 IDS_COOKIES_APPLICATION_CACHES)) { | 714 IDS_COOKIES_APPLICATION_CACHES)) { |
588 } | 715 } |
589 | 716 |
590 CookieTreeAppCachesNode::~CookieTreeAppCachesNode() {} | 717 CookieTreeAppCachesNode::~CookieTreeAppCachesNode() {} |
591 | 718 |
592 CookieTreeNode::DetailedInfo CookieTreeAppCachesNode::GetDetailedInfo() const { | 719 CookieTreeNode::DetailedInfo CookieTreeAppCachesNode::GetDetailedInfo() const { |
593 return DetailedInfo(parent()->GetTitle()).Init(DetailedInfo::TYPE_APPCACHES); | 720 return DetailedInfo().Init(DetailedInfo::TYPE_APPCACHES); |
594 } | 721 } |
595 | 722 |
596 /////////////////////////////////////////////////////////////////////////////// | 723 /////////////////////////////////////////////////////////////////////////////// |
597 // CookieTreeDatabasesNode, public: | 724 // CookieTreeDatabasesNode, public: |
598 | 725 |
599 CookieTreeDatabasesNode::CookieTreeDatabasesNode() | 726 CookieTreeDatabasesNode::CookieTreeDatabasesNode() |
600 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASES)) { | 727 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASES)) { |
601 } | 728 } |
602 | 729 |
603 CookieTreeDatabasesNode::~CookieTreeDatabasesNode() {} | 730 CookieTreeDatabasesNode::~CookieTreeDatabasesNode() {} |
604 | 731 |
605 CookieTreeNode::DetailedInfo CookieTreeDatabasesNode::GetDetailedInfo() const { | 732 CookieTreeNode::DetailedInfo CookieTreeDatabasesNode::GetDetailedInfo() const { |
606 return DetailedInfo(parent()->GetTitle()).Init(DetailedInfo::TYPE_DATABASES); | 733 return DetailedInfo().Init(DetailedInfo::TYPE_DATABASES); |
607 } | 734 } |
608 | 735 |
609 /////////////////////////////////////////////////////////////////////////////// | 736 /////////////////////////////////////////////////////////////////////////////// |
610 // CookieTreeLocalStoragesNode, public: | 737 // CookieTreeLocalStoragesNode, public: |
611 | 738 |
612 CookieTreeLocalStoragesNode::CookieTreeLocalStoragesNode() | 739 CookieTreeLocalStoragesNode::CookieTreeLocalStoragesNode() |
613 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_LOCAL_STORAGE)) { | 740 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_LOCAL_STORAGE)) { |
614 } | 741 } |
615 | 742 |
616 CookieTreeLocalStoragesNode::~CookieTreeLocalStoragesNode() {} | 743 CookieTreeLocalStoragesNode::~CookieTreeLocalStoragesNode() {} |
617 | 744 |
618 CookieTreeNode::DetailedInfo | 745 CookieTreeNode::DetailedInfo |
619 CookieTreeLocalStoragesNode::GetDetailedInfo() const { | 746 CookieTreeLocalStoragesNode::GetDetailedInfo() const { |
620 return DetailedInfo(parent()->GetTitle()).Init( | 747 return DetailedInfo().Init(DetailedInfo::TYPE_LOCAL_STORAGES); |
621 DetailedInfo::TYPE_LOCAL_STORAGES); | |
622 } | 748 } |
623 | 749 |
624 /////////////////////////////////////////////////////////////////////////////// | 750 /////////////////////////////////////////////////////////////////////////////// |
625 // CookieTreeSessionStoragesNode, public: | 751 // CookieTreeSessionStoragesNode, public: |
626 | 752 |
627 CookieTreeSessionStoragesNode::CookieTreeSessionStoragesNode() | 753 CookieTreeSessionStoragesNode::CookieTreeSessionStoragesNode() |
628 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_SESSION_STORAGE)) { | 754 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_SESSION_STORAGE)) { |
629 } | 755 } |
630 | 756 |
631 CookieTreeSessionStoragesNode::~CookieTreeSessionStoragesNode() {} | 757 CookieTreeSessionStoragesNode::~CookieTreeSessionStoragesNode() {} |
632 | 758 |
633 CookieTreeNode::DetailedInfo | 759 CookieTreeNode::DetailedInfo |
634 CookieTreeSessionStoragesNode::GetDetailedInfo() const { | 760 CookieTreeSessionStoragesNode::GetDetailedInfo() const { |
635 return DetailedInfo(parent()->GetTitle()).Init( | 761 return DetailedInfo().Init(DetailedInfo::TYPE_SESSION_STORAGES); |
636 DetailedInfo::TYPE_SESSION_STORAGES); | |
637 } | 762 } |
638 | 763 |
639 /////////////////////////////////////////////////////////////////////////////// | 764 /////////////////////////////////////////////////////////////////////////////// |
640 // CookieTreeIndexedDBsNode, public: | 765 // CookieTreeIndexedDBsNode, public: |
641 | 766 |
642 CookieTreeIndexedDBsNode::CookieTreeIndexedDBsNode() | 767 CookieTreeIndexedDBsNode::CookieTreeIndexedDBsNode() |
643 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_INDEXED_DBS)) { | 768 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_INDEXED_DBS)) { |
644 } | 769 } |
645 | 770 |
646 CookieTreeIndexedDBsNode::~CookieTreeIndexedDBsNode() {} | 771 CookieTreeIndexedDBsNode::~CookieTreeIndexedDBsNode() {} |
647 | 772 |
648 CookieTreeNode::DetailedInfo | 773 CookieTreeNode::DetailedInfo |
649 CookieTreeIndexedDBsNode::GetDetailedInfo() const { | 774 CookieTreeIndexedDBsNode::GetDetailedInfo() const { |
650 return DetailedInfo(parent()->GetTitle()).Init( | 775 return DetailedInfo().Init(DetailedInfo::TYPE_INDEXED_DBS); |
651 DetailedInfo::TYPE_INDEXED_DBS); | |
652 } | 776 } |
653 | 777 |
654 /////////////////////////////////////////////////////////////////////////////// | 778 /////////////////////////////////////////////////////////////////////////////// |
655 // CookieTreeFileSystemsNode, public: | 779 // CookieTreeFileSystemsNode, public: |
656 | 780 |
657 CookieTreeFileSystemsNode::CookieTreeFileSystemsNode() | 781 CookieTreeFileSystemsNode::CookieTreeFileSystemsNode() |
658 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_FILE_SYSTEMS)) { | 782 : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_FILE_SYSTEMS)) { |
659 } | 783 } |
660 | 784 |
661 CookieTreeFileSystemsNode::~CookieTreeFileSystemsNode() {} | 785 CookieTreeFileSystemsNode::~CookieTreeFileSystemsNode() {} |
662 | 786 |
663 CookieTreeNode::DetailedInfo | 787 CookieTreeNode::DetailedInfo |
664 CookieTreeFileSystemsNode::GetDetailedInfo() const { | 788 CookieTreeFileSystemsNode::GetDetailedInfo() const { |
665 return DetailedInfo(parent()->GetTitle()).Init( | 789 return DetailedInfo().Init(DetailedInfo::TYPE_FILE_SYSTEMS); |
666 DetailedInfo::TYPE_FILE_SYSTEMS); | |
667 } | 790 } |
668 | 791 |
669 /////////////////////////////////////////////////////////////////////////////// | 792 /////////////////////////////////////////////////////////////////////////////// |
670 // CookieTreeServerBoundCertsNode, public: | 793 // CookieTreeServerBoundCertsNode, public: |
671 | 794 |
672 CookieTreeServerBoundCertsNode::CookieTreeServerBoundCertsNode() | 795 CookieTreeServerBoundCertsNode::CookieTreeServerBoundCertsNode() |
673 : CookieTreeNode( | 796 : CookieTreeNode( |
674 l10n_util::GetStringUTF16(IDS_COOKIES_SERVER_BOUND_CERTS)) { | 797 l10n_util::GetStringUTF16(IDS_COOKIES_SERVER_BOUND_CERTS)) { |
675 } | 798 } |
676 | 799 |
677 CookieTreeServerBoundCertsNode::~CookieTreeServerBoundCertsNode() {} | 800 CookieTreeServerBoundCertsNode::~CookieTreeServerBoundCertsNode() {} |
678 | 801 |
679 CookieTreeNode::DetailedInfo | 802 CookieTreeNode::DetailedInfo |
680 CookieTreeServerBoundCertsNode::GetDetailedInfo() const { | 803 CookieTreeServerBoundCertsNode::GetDetailedInfo() const { |
681 return DetailedInfo(parent()->GetTitle()).Init( | 804 return DetailedInfo().Init(DetailedInfo::TYPE_SERVER_BOUND_CERTS); |
682 DetailedInfo::TYPE_SERVER_BOUND_CERTS); | |
683 } | 805 } |
684 | 806 |
685 void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) { | 807 void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) { |
686 DCHECK(new_child); | 808 DCHECK(new_child); |
687 std::vector<CookieTreeNode*>::iterator iter = | 809 std::vector<CookieTreeNode*>::iterator iter = |
688 std::lower_bound(children().begin(), children().end(), new_child, | 810 std::lower_bound(children().begin(), children().end(), new_child, |
689 NodeTitleComparator()); | 811 NodeTitleComparator()); |
690 GetModel()->Add(this, new_child, iter - children().begin()); | 812 GetModel()->Add(this, new_child, iter - children().begin()); |
691 } | 813 } |
692 | 814 |
(...skipping 13 matching lines...) Expand all Loading... |
706 | 828 |
707 void CookiesTreeModel::ScopedBatchUpdateNotifier::StartBatchUpdate() { | 829 void CookiesTreeModel::ScopedBatchUpdateNotifier::StartBatchUpdate() { |
708 if (!batch_in_progress_) { | 830 if (!batch_in_progress_) { |
709 model_->NotifyObserverBeginBatch(); | 831 model_->NotifyObserverBeginBatch(); |
710 batch_in_progress_ = true; | 832 batch_in_progress_ = true; |
711 } | 833 } |
712 } | 834 } |
713 | 835 |
714 /////////////////////////////////////////////////////////////////////////////// | 836 /////////////////////////////////////////////////////////////////////////////// |
715 // CookiesTreeModel, public: | 837 // CookiesTreeModel, public: |
716 CookiesTreeModel::CookiesTreeModel(const ContainerMap& apps_map, | 838 CookiesTreeModel::CookiesTreeModel( |
717 bool group_by_cookie_source) | 839 const ContainerMap& apps_map, |
| 840 ExtensionSpecialStoragePolicy* special_storage_policy, |
| 841 bool group_by_cookie_source) |
718 : ALLOW_THIS_IN_INITIALIZER_LIST(ui::TreeNodeModel<CookieTreeNode>( | 842 : ALLOW_THIS_IN_INITIALIZER_LIST(ui::TreeNodeModel<CookieTreeNode>( |
719 new CookieTreeRootNode(this))), | 843 new CookieTreeRootNode(this))), |
720 app_data_map_(apps_map), | 844 app_data_map_(apps_map), |
| 845 special_storage_policy_(special_storage_policy), |
721 group_by_cookie_source_(group_by_cookie_source), | 846 group_by_cookie_source_(group_by_cookie_source), |
722 batch_update_(0) { | 847 batch_update_(0) { |
723 for (ContainerMap::const_iterator it = apps_map.begin(); | 848 for (ContainerMap::const_iterator it = apps_map.begin(); |
724 it != apps_map.end(); ++it) { | 849 it != apps_map.end(); ++it) { |
725 it->second->Init(this); | 850 it->second->Init(this); |
726 } | 851 } |
727 } | 852 } |
728 | 853 |
729 CookiesTreeModel::~CookiesTreeModel() { | 854 CookiesTreeModel::~CookiesTreeModel() { |
730 STLDeleteValues(&app_data_map_); | 855 STLDeleteValues(&app_data_map_); |
(...skipping 13 matching lines...) Expand all Loading... |
744 icons->push_back(*ResourceBundle::GetSharedInstance().GetImageSkiaNamed( | 869 icons->push_back(*ResourceBundle::GetSharedInstance().GetImageSkiaNamed( |
745 IDR_COOKIE_STORAGE_ICON)); | 870 IDR_COOKIE_STORAGE_ICON)); |
746 } | 871 } |
747 | 872 |
748 // Returns the index of the icon to use for |node|. Return -1 to use the | 873 // Returns the index of the icon to use for |node|. Return -1 to use the |
749 // default icon. The index is relative to the list of icons returned from | 874 // default icon. The index is relative to the list of icons returned from |
750 // GetIcons. | 875 // GetIcons. |
751 int CookiesTreeModel::GetIconIndex(ui::TreeModelNode* node) { | 876 int CookiesTreeModel::GetIconIndex(ui::TreeModelNode* node) { |
752 CookieTreeNode* ct_node = static_cast<CookieTreeNode*>(node); | 877 CookieTreeNode* ct_node = static_cast<CookieTreeNode*>(node); |
753 switch (ct_node->GetDetailedInfo().node_type) { | 878 switch (ct_node->GetDetailedInfo().node_type) { |
754 case CookieTreeNode::DetailedInfo::TYPE_ORIGIN: | 879 case CookieTreeNode::DetailedInfo::TYPE_HOST: |
755 return ORIGIN; | 880 return ORIGIN; |
756 case CookieTreeNode::DetailedInfo::TYPE_COOKIE: | 881 case CookieTreeNode::DetailedInfo::TYPE_COOKIE: |
757 return COOKIE; | 882 return COOKIE; |
758 case CookieTreeNode::DetailedInfo::TYPE_DATABASE: | 883 case CookieTreeNode::DetailedInfo::TYPE_DATABASE: |
759 return DATABASE; | 884 return DATABASE; |
760 case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE: | 885 case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE: |
761 return DATABASE; // close enough | 886 return DATABASE; // close enough |
762 case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE: | 887 case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE: |
763 return DATABASE; // ditto | 888 return DATABASE; // ditto |
764 case CookieTreeNode::DetailedInfo::TYPE_APPCACHE: | 889 case CookieTreeNode::DetailedInfo::TYPE_APPCACHE: |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
815 PopulateLocalStorageInfoWithFilter(container, ¬ifier, filter); | 940 PopulateLocalStorageInfoWithFilter(container, ¬ifier, filter); |
816 PopulateSessionStorageInfoWithFilter(container, ¬ifier, filter); | 941 PopulateSessionStorageInfoWithFilter(container, ¬ifier, filter); |
817 PopulateAppCacheInfoWithFilter(container, ¬ifier, filter); | 942 PopulateAppCacheInfoWithFilter(container, ¬ifier, filter); |
818 PopulateIndexedDBInfoWithFilter(container, ¬ifier, filter); | 943 PopulateIndexedDBInfoWithFilter(container, ¬ifier, filter); |
819 PopulateFileSystemInfoWithFilter(container, ¬ifier, filter); | 944 PopulateFileSystemInfoWithFilter(container, ¬ifier, filter); |
820 PopulateQuotaInfoWithFilter(container, ¬ifier, filter); | 945 PopulateQuotaInfoWithFilter(container, ¬ifier, filter); |
821 PopulateServerBoundCertInfoWithFilter(container, ¬ifier, filter); | 946 PopulateServerBoundCertInfoWithFilter(container, ¬ifier, filter); |
822 } | 947 } |
823 } | 948 } |
824 | 949 |
| 950 const ExtensionSet* CookiesTreeModel::ExtensionsProtectingNode( |
| 951 const CookieTreeNode& cookie_node) { |
| 952 if (!special_storage_policy_) |
| 953 return NULL; |
| 954 |
| 955 CookieTreeNode::DetailedInfo info = cookie_node.GetDetailedInfo(); |
| 956 |
| 957 if (!TypeIsProtected(info.node_type)) |
| 958 return NULL; |
| 959 |
| 960 DCHECK(!info.origin.is_empty()); |
| 961 return special_storage_policy_->ExtensionsProtectingOrigin(info.origin); |
| 962 } |
| 963 |
825 void CookiesTreeModel::AddCookiesTreeObserver(Observer* observer) { | 964 void CookiesTreeModel::AddCookiesTreeObserver(Observer* observer) { |
826 cookies_observer_list_.AddObserver(observer); | 965 cookies_observer_list_.AddObserver(observer); |
827 // Call super so that TreeNodeModel can notify, too. | 966 // Call super so that TreeNodeModel can notify, too. |
828 ui::TreeNodeModel<CookieTreeNode>::AddObserver(observer); | 967 ui::TreeNodeModel<CookieTreeNode>::AddObserver(observer); |
829 } | 968 } |
830 | 969 |
831 void CookiesTreeModel::RemoveCookiesTreeObserver(Observer* observer) { | 970 void CookiesTreeModel::RemoveCookiesTreeObserver(Observer* observer) { |
832 cookies_observer_list_.RemoveObserver(observer); | 971 cookies_observer_list_.RemoveObserver(observer); |
833 // Call super so that TreeNodeModel doesn't have dead pointers. | 972 // Call super so that TreeNodeModel doesn't have dead pointers. |
834 ui::TreeNodeModel<CookieTreeNode>::RemoveObserver(observer); | 973 ui::TreeNodeModel<CookieTreeNode>::RemoveObserver(observer); |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
888 using appcache::AppCacheInfo; | 1027 using appcache::AppCacheInfo; |
889 typedef std::map<GURL, std::list<AppCacheInfo> > InfoByOrigin; | 1028 typedef std::map<GURL, std::list<AppCacheInfo> > InfoByOrigin; |
890 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1029 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
891 | 1030 |
892 if (container->appcache_info_.empty()) | 1031 if (container->appcache_info_.empty()) |
893 return; | 1032 return; |
894 | 1033 |
895 notifier->StartBatchUpdate(); | 1034 notifier->StartBatchUpdate(); |
896 for (InfoByOrigin::iterator origin = container->appcache_info_.begin(); | 1035 for (InfoByOrigin::iterator origin = container->appcache_info_.begin(); |
897 origin != container->appcache_info_.end(); ++origin) { | 1036 origin != container->appcache_info_.end(); ++origin) { |
898 string16 origin_node_name = UTF8ToUTF16(origin->first.host()); | 1037 string16 host_node_name = UTF8ToUTF16(origin->first.host()); |
899 if (filter.empty() || | 1038 if (filter.empty() || |
900 (origin_node_name.find(filter) != string16::npos)) { | 1039 (host_node_name.find(filter) != string16::npos)) { |
901 CookieTreeOriginNode* origin_node = | 1040 CookieTreeHostNode* host_node = |
902 root->GetOrCreateOriginNode(origin->first, container->app_id(), | 1041 root->GetOrCreateHostNode(origin->first, container->app_id(), |
903 container->app_name()); | 1042 container->app_name()); |
904 CookieTreeAppCachesNode* appcaches_node = | 1043 CookieTreeAppCachesNode* appcaches_node = |
905 origin_node->GetOrCreateAppCachesNode(); | 1044 host_node->GetOrCreateAppCachesNode(); |
906 | 1045 |
907 for (std::list<AppCacheInfo>::iterator info = origin->second.begin(); | 1046 for (std::list<AppCacheInfo>::iterator info = origin->second.begin(); |
908 info != origin->second.end(); ++info) { | 1047 info != origin->second.end(); ++info) { |
909 appcaches_node->AddAppCacheNode( | 1048 appcaches_node->AddAppCacheNode( |
910 new CookieTreeAppCacheNode(origin->first, info)); | 1049 new CookieTreeAppCacheNode(origin->first, info)); |
911 } | 1050 } |
912 } | 1051 } |
913 } | 1052 } |
914 } | 1053 } |
915 | 1054 |
(...skipping 12 matching lines...) Expand all Loading... |
928 if (domain.length() > 1 && domain[0] == '.') | 1067 if (domain.length() > 1 && domain[0] == '.') |
929 domain = domain.substr(1); | 1068 domain = domain.substr(1); |
930 | 1069 |
931 // We treat secure cookies just the same as normal ones. | 1070 // We treat secure cookies just the same as normal ones. |
932 source_string = std::string(chrome::kHttpScheme) + | 1071 source_string = std::string(chrome::kHttpScheme) + |
933 content::kStandardSchemeSeparator + domain + "/"; | 1072 content::kStandardSchemeSeparator + domain + "/"; |
934 } | 1073 } |
935 | 1074 |
936 GURL source(source_string); | 1075 GURL source(source_string); |
937 if (!filter.size() || | 1076 if (!filter.size() || |
938 (CookieTreeOriginNode::TitleForUrl(source, container->app_id(), | 1077 (CookieTreeHostNode::TitleForUrl(source, container->app_id(), |
939 container->app_name()).find(filter) != string16::npos)) { | 1078 container->app_name()).find(filter) != string16::npos)) { |
940 CookieTreeOriginNode* origin_node = | 1079 CookieTreeHostNode* host_node = |
941 root->GetOrCreateOriginNode(source, container->app_id(), | 1080 root->GetOrCreateHostNode(source, container->app_id(), |
942 container->app_name()); | 1081 container->app_name()); |
943 CookieTreeCookiesNode* cookies_node = | 1082 CookieTreeCookiesNode* cookies_node = |
944 origin_node->GetOrCreateCookiesNode(); | 1083 host_node->GetOrCreateCookiesNode(); |
945 CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it); | 1084 CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it); |
946 cookies_node->AddCookieNode(new_cookie); | 1085 cookies_node->AddCookieNode(new_cookie); |
947 } | 1086 } |
948 } | 1087 } |
949 } | 1088 } |
950 | 1089 |
951 void CookiesTreeModel::PopulateDatabaseInfoWithFilter( | 1090 void CookiesTreeModel::PopulateDatabaseInfoWithFilter( |
952 LocalDataContainer* container, | 1091 LocalDataContainer* container, |
953 ScopedBatchUpdateNotifier* notifier, | 1092 ScopedBatchUpdateNotifier* notifier, |
954 const string16& filter) { | 1093 const string16& filter) { |
955 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1094 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
956 | 1095 |
957 if (container->database_info_list_.empty()) | 1096 if (container->database_info_list_.empty()) |
958 return; | 1097 return; |
959 | 1098 |
960 notifier->StartBatchUpdate(); | 1099 notifier->StartBatchUpdate(); |
961 for (DatabaseInfoList::iterator database_info = | 1100 for (DatabaseInfoList::iterator database_info = |
962 container->database_info_list_.begin(); | 1101 container->database_info_list_.begin(); |
963 database_info != container->database_info_list_.end(); | 1102 database_info != container->database_info_list_.end(); |
964 ++database_info) { | 1103 ++database_info) { |
965 GURL origin(database_info->origin); | 1104 GURL origin(database_info->origin); |
966 | 1105 |
967 if (!filter.size() || | 1106 if (!filter.size() || |
968 (CookieTreeOriginNode::TitleForUrl(origin, container->app_id(), | 1107 (CookieTreeHostNode::TitleForUrl(origin, container->app_id(), |
969 container->app_name()).find(filter) != string16::npos)) { | 1108 container->app_name()).find(filter) != string16::npos)) { |
970 CookieTreeOriginNode* origin_node = | 1109 CookieTreeHostNode* host_node = |
971 root->GetOrCreateOriginNode(origin, container->app_id(), | 1110 root->GetOrCreateHostNode(origin, container->app_id(), |
972 container->app_name()); | 1111 container->app_name()); |
973 CookieTreeDatabasesNode* databases_node = | 1112 CookieTreeDatabasesNode* databases_node = |
974 origin_node->GetOrCreateDatabasesNode(); | 1113 host_node->GetOrCreateDatabasesNode(); |
975 databases_node->AddDatabaseNode( | 1114 databases_node->AddDatabaseNode( |
976 new CookieTreeDatabaseNode(database_info)); | 1115 new CookieTreeDatabaseNode(database_info)); |
977 } | 1116 } |
978 } | 1117 } |
979 } | 1118 } |
980 | 1119 |
981 void CookiesTreeModel::PopulateLocalStorageInfoWithFilter( | 1120 void CookiesTreeModel::PopulateLocalStorageInfoWithFilter( |
982 LocalDataContainer* container, | 1121 LocalDataContainer* container, |
983 ScopedBatchUpdateNotifier* notifier, | 1122 ScopedBatchUpdateNotifier* notifier, |
984 const string16& filter) { | 1123 const string16& filter) { |
985 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1124 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
986 | 1125 |
987 if (container->local_storage_info_list_.empty()) | 1126 if (container->local_storage_info_list_.empty()) |
988 return; | 1127 return; |
989 | 1128 |
990 notifier->StartBatchUpdate(); | 1129 notifier->StartBatchUpdate(); |
991 for (LocalStorageInfoList::iterator local_storage_info = | 1130 for (LocalStorageInfoList::iterator local_storage_info = |
992 container->local_storage_info_list_.begin(); | 1131 container->local_storage_info_list_.begin(); |
993 local_storage_info != container->local_storage_info_list_.end(); | 1132 local_storage_info != container->local_storage_info_list_.end(); |
994 ++local_storage_info) { | 1133 ++local_storage_info) { |
995 const GURL& origin(local_storage_info->origin_url); | 1134 const GURL& origin(local_storage_info->origin_url); |
996 | 1135 |
997 if (!filter.size() || | 1136 if (!filter.size() || |
998 (CookieTreeOriginNode::TitleForUrl(origin, container->app_id(), | 1137 (CookieTreeHostNode::TitleForUrl(origin, container->app_id(), |
999 container->app_name()).find(filter) != std::string::npos)) { | 1138 container->app_name()).find(filter) != std::string::npos)) { |
1000 CookieTreeOriginNode* origin_node = | 1139 CookieTreeHostNode* host_node = |
1001 root->GetOrCreateOriginNode(origin, container->app_id(), | 1140 root->GetOrCreateHostNode(origin, container->app_id(), |
1002 container->app_name()); | 1141 container->app_name()); |
1003 CookieTreeLocalStoragesNode* local_storages_node = | 1142 CookieTreeLocalStoragesNode* local_storages_node = |
1004 origin_node->GetOrCreateLocalStoragesNode(); | 1143 host_node->GetOrCreateLocalStoragesNode(); |
1005 local_storages_node->AddLocalStorageNode( | 1144 local_storages_node->AddLocalStorageNode( |
1006 new CookieTreeLocalStorageNode(local_storage_info)); | 1145 new CookieTreeLocalStorageNode(local_storage_info)); |
1007 } | 1146 } |
1008 } | 1147 } |
1009 } | 1148 } |
1010 | 1149 |
1011 void CookiesTreeModel::PopulateSessionStorageInfoWithFilter( | 1150 void CookiesTreeModel::PopulateSessionStorageInfoWithFilter( |
1012 LocalDataContainer* container, | 1151 LocalDataContainer* container, |
1013 ScopedBatchUpdateNotifier* notifier, | 1152 ScopedBatchUpdateNotifier* notifier, |
1014 const string16& filter) { | 1153 const string16& filter) { |
1015 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1154 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
1016 | 1155 |
1017 if (container->session_storage_info_list_.empty()) | 1156 if (container->session_storage_info_list_.empty()) |
1018 return; | 1157 return; |
1019 | 1158 |
1020 notifier->StartBatchUpdate(); | 1159 notifier->StartBatchUpdate(); |
1021 for (LocalStorageInfoList::iterator session_storage_info = | 1160 for (LocalStorageInfoList::iterator session_storage_info = |
1022 container->session_storage_info_list_.begin(); | 1161 container->session_storage_info_list_.begin(); |
1023 session_storage_info != container->session_storage_info_list_.end(); | 1162 session_storage_info != container->session_storage_info_list_.end(); |
1024 ++session_storage_info) { | 1163 ++session_storage_info) { |
1025 const GURL& origin = session_storage_info->origin_url; | 1164 const GURL& origin = session_storage_info->origin_url; |
1026 | 1165 |
1027 if (!filter.size() || | 1166 if (!filter.size() || |
1028 (CookieTreeOriginNode::TitleForUrl(origin, container->app_id(), | 1167 (CookieTreeHostNode::TitleForUrl(origin, container->app_id(), |
1029 container->app_name()).find(filter) != string16::npos)) { | 1168 container->app_name()).find(filter) != string16::npos)) { |
1030 CookieTreeOriginNode* origin_node = | 1169 CookieTreeHostNode* host_node = |
1031 root->GetOrCreateOriginNode(origin, container->app_id(), | 1170 root->GetOrCreateHostNode(origin, container->app_id(), |
1032 container->app_name()); | 1171 container->app_name()); |
1033 CookieTreeSessionStoragesNode* session_storages_node = | 1172 CookieTreeSessionStoragesNode* session_storages_node = |
1034 origin_node->GetOrCreateSessionStoragesNode(); | 1173 host_node->GetOrCreateSessionStoragesNode(); |
1035 session_storages_node->AddSessionStorageNode( | 1174 session_storages_node->AddSessionStorageNode( |
1036 new CookieTreeSessionStorageNode(session_storage_info)); | 1175 new CookieTreeSessionStorageNode(session_storage_info)); |
1037 } | 1176 } |
1038 } | 1177 } |
1039 } | 1178 } |
1040 | 1179 |
1041 void CookiesTreeModel::PopulateIndexedDBInfoWithFilter( | 1180 void CookiesTreeModel::PopulateIndexedDBInfoWithFilter( |
1042 LocalDataContainer* container, | 1181 LocalDataContainer* container, |
1043 ScopedBatchUpdateNotifier* notifier, | 1182 ScopedBatchUpdateNotifier* notifier, |
1044 const string16& filter) { | 1183 const string16& filter) { |
1045 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1184 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
1046 | 1185 |
1047 if (container->indexed_db_info_list_.empty()) | 1186 if (container->indexed_db_info_list_.empty()) |
1048 return; | 1187 return; |
1049 | 1188 |
1050 notifier->StartBatchUpdate(); | 1189 notifier->StartBatchUpdate(); |
1051 for (IndexedDBInfoList::iterator indexed_db_info = | 1190 for (IndexedDBInfoList::iterator indexed_db_info = |
1052 container->indexed_db_info_list_.begin(); | 1191 container->indexed_db_info_list_.begin(); |
1053 indexed_db_info != container->indexed_db_info_list_.end(); | 1192 indexed_db_info != container->indexed_db_info_list_.end(); |
1054 ++indexed_db_info) { | 1193 ++indexed_db_info) { |
1055 const GURL& origin = indexed_db_info->origin; | 1194 const GURL& origin = indexed_db_info->origin; |
1056 | 1195 |
1057 if (!filter.size() || | 1196 if (!filter.size() || |
1058 (CookieTreeOriginNode::TitleForUrl(origin, container->app_id(), | 1197 (CookieTreeHostNode::TitleForUrl(origin, container->app_id(), |
1059 container->app_name()).find(filter) != string16::npos)) { | 1198 container->app_name()).find(filter) != string16::npos)) { |
1060 CookieTreeOriginNode* origin_node = | 1199 CookieTreeHostNode* host_node = |
1061 root->GetOrCreateOriginNode(origin, container->app_id(), | 1200 root->GetOrCreateHostNode(origin, container->app_id(), |
1062 container->app_name()); | 1201 container->app_name()); |
1063 CookieTreeIndexedDBsNode* indexed_dbs_node = | 1202 CookieTreeIndexedDBsNode* indexed_dbs_node = |
1064 origin_node->GetOrCreateIndexedDBsNode(); | 1203 host_node->GetOrCreateIndexedDBsNode(); |
1065 indexed_dbs_node->AddIndexedDBNode( | 1204 indexed_dbs_node->AddIndexedDBNode( |
1066 new CookieTreeIndexedDBNode(indexed_db_info)); | 1205 new CookieTreeIndexedDBNode(indexed_db_info)); |
1067 } | 1206 } |
1068 } | 1207 } |
1069 } | 1208 } |
1070 | 1209 |
1071 void CookiesTreeModel::PopulateServerBoundCertInfoWithFilter( | 1210 void CookiesTreeModel::PopulateServerBoundCertInfoWithFilter( |
1072 LocalDataContainer* container, | 1211 LocalDataContainer* container, |
1073 ScopedBatchUpdateNotifier* notifier, | 1212 ScopedBatchUpdateNotifier* notifier, |
1074 const string16& filter) { | 1213 const string16& filter) { |
1075 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1214 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
1076 | 1215 |
1077 if (container->server_bound_cert_list_.empty()) | 1216 if (container->server_bound_cert_list_.empty()) |
1078 return; | 1217 return; |
1079 | 1218 |
1080 notifier->StartBatchUpdate(); | 1219 notifier->StartBatchUpdate(); |
1081 for (ServerBoundCertList::iterator cert_info = | 1220 for (ServerBoundCertList::iterator cert_info = |
1082 container->server_bound_cert_list_.begin(); | 1221 container->server_bound_cert_list_.begin(); |
1083 cert_info != container->server_bound_cert_list_.end(); | 1222 cert_info != container->server_bound_cert_list_.end(); |
1084 ++cert_info) { | 1223 ++cert_info) { |
1085 GURL origin(cert_info->server_identifier()); | 1224 GURL origin(cert_info->server_identifier()); |
1086 if (!origin.is_valid()) { | 1225 if (!origin.is_valid()) { |
1087 // Domain Bound Cert. Make a valid URL to satisfy the | 1226 // Domain Bound Cert. Make a valid URL to satisfy the |
1088 // CookieTreeRootNode::GetOrCreateOriginNode interface. | 1227 // CookieTreeRootNode::GetOrCreateHostNode interface. |
1089 origin = GURL(std::string(chrome::kHttpsScheme) + | 1228 origin = GURL(std::string(chrome::kHttpsScheme) + |
1090 content::kStandardSchemeSeparator + | 1229 content::kStandardSchemeSeparator + |
1091 cert_info->server_identifier() + "/"); | 1230 cert_info->server_identifier() + "/"); |
1092 } | 1231 } |
1093 string16 title = CookieTreeOriginNode::TitleForUrl(origin, | 1232 string16 title = CookieTreeHostNode::TitleForUrl(origin, |
1094 container->app_id(), | 1233 container->app_id(), |
1095 container->app_name()); | 1234 container->app_name()); |
1096 | 1235 |
1097 if (!filter.size() || title.find(filter) != string16::npos) { | 1236 if (!filter.size() || title.find(filter) != string16::npos) { |
1098 CookieTreeOriginNode* origin_node = | 1237 CookieTreeHostNode* host_node = |
1099 root->GetOrCreateOriginNode(origin, container->app_id(), | 1238 root->GetOrCreateHostNode(origin, container->app_id(), |
1100 container->app_name()); | 1239 container->app_name()); |
1101 CookieTreeServerBoundCertsNode* server_bound_certs_node = | 1240 CookieTreeServerBoundCertsNode* server_bound_certs_node = |
1102 origin_node->GetOrCreateServerBoundCertsNode(); | 1241 host_node->GetOrCreateServerBoundCertsNode(); |
1103 server_bound_certs_node->AddServerBoundCertNode( | 1242 server_bound_certs_node->AddServerBoundCertNode( |
1104 new CookieTreeServerBoundCertNode(cert_info)); | 1243 new CookieTreeServerBoundCertNode(cert_info)); |
1105 } | 1244 } |
1106 } | 1245 } |
1107 } | 1246 } |
1108 | 1247 |
1109 void CookiesTreeModel::PopulateFileSystemInfoWithFilter( | 1248 void CookiesTreeModel::PopulateFileSystemInfoWithFilter( |
1110 LocalDataContainer* container, | 1249 LocalDataContainer* container, |
1111 ScopedBatchUpdateNotifier* notifier, | 1250 ScopedBatchUpdateNotifier* notifier, |
1112 const string16& filter) { | 1251 const string16& filter) { |
1113 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1252 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
1114 | 1253 |
1115 if (container->file_system_info_list_.empty()) | 1254 if (container->file_system_info_list_.empty()) |
1116 return; | 1255 return; |
1117 | 1256 |
1118 notifier->StartBatchUpdate(); | 1257 notifier->StartBatchUpdate(); |
1119 for (FileSystemInfoList::iterator file_system_info = | 1258 for (FileSystemInfoList::iterator file_system_info = |
1120 container->file_system_info_list_.begin(); | 1259 container->file_system_info_list_.begin(); |
1121 file_system_info != container->file_system_info_list_.end(); | 1260 file_system_info != container->file_system_info_list_.end(); |
1122 ++file_system_info) { | 1261 ++file_system_info) { |
1123 GURL origin(file_system_info->origin); | 1262 GURL origin(file_system_info->origin); |
1124 | 1263 |
1125 if (!filter.size() || | 1264 if (!filter.size() || |
1126 (CookieTreeOriginNode::TitleForUrl(origin, container->app_id(), | 1265 (CookieTreeHostNode::TitleForUrl(origin, container->app_id(), |
1127 container->app_name()).find(filter) != string16::npos)) { | 1266 container->app_name()).find(filter) != string16::npos)) { |
1128 CookieTreeOriginNode* origin_node = | 1267 CookieTreeHostNode* host_node = |
1129 root->GetOrCreateOriginNode(origin, container->app_id(), | 1268 root->GetOrCreateHostNode(origin, container->app_id(), |
1130 container->app_name()); | 1269 container->app_name()); |
1131 CookieTreeFileSystemsNode* file_systems_node = | 1270 CookieTreeFileSystemsNode* file_systems_node = |
1132 origin_node->GetOrCreateFileSystemsNode(); | 1271 host_node->GetOrCreateFileSystemsNode(); |
1133 file_systems_node->AddFileSystemNode( | 1272 file_systems_node->AddFileSystemNode( |
1134 new CookieTreeFileSystemNode(file_system_info)); | 1273 new CookieTreeFileSystemNode(file_system_info)); |
1135 } | 1274 } |
1136 } | 1275 } |
1137 } | 1276 } |
1138 | 1277 |
1139 void CookiesTreeModel::PopulateQuotaInfoWithFilter( | 1278 void CookiesTreeModel::PopulateQuotaInfoWithFilter( |
1140 LocalDataContainer* container, | 1279 LocalDataContainer* container, |
1141 ScopedBatchUpdateNotifier* notifier, | 1280 ScopedBatchUpdateNotifier* notifier, |
1142 const string16& filter) { | 1281 const string16& filter) { |
1143 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); | 1282 CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot()); |
1144 | 1283 |
1145 if (container->quota_info_list_.empty()) | 1284 if (container->quota_info_list_.empty()) |
1146 return; | 1285 return; |
1147 | 1286 |
1148 notifier->StartBatchUpdate(); | 1287 notifier->StartBatchUpdate(); |
1149 for (QuotaInfoList::iterator quota_info = container->quota_info_list_.begin(); | 1288 for (QuotaInfoList::iterator quota_info = container->quota_info_list_.begin(); |
1150 quota_info != container->quota_info_list_.end(); | 1289 quota_info != container->quota_info_list_.end(); |
1151 ++quota_info) { | 1290 ++quota_info) { |
1152 if (!filter.size() || | 1291 if (!filter.size() || |
1153 (UTF8ToUTF16(quota_info->host).find(filter) != string16::npos)) { | 1292 (UTF8ToUTF16(quota_info->host).find(filter) != string16::npos)) { |
1154 CookieTreeOriginNode* origin_node = | 1293 CookieTreeHostNode* host_node = |
1155 root->GetOrCreateOriginNode(GURL("http://" + quota_info->host), | 1294 root->GetOrCreateHostNode(GURL("http://" + quota_info->host), |
1156 container->app_id(), | 1295 container->app_id(), |
1157 container->app_name()); | 1296 container->app_name()); |
1158 origin_node->UpdateOrCreateQuotaNode(quota_info); | 1297 host_node->UpdateOrCreateQuotaNode(quota_info); |
1159 } | 1298 } |
1160 } | 1299 } |
1161 } | 1300 } |
1162 | 1301 |
1163 void CookiesTreeModel::NotifyObserverBeginBatch() { | 1302 void CookiesTreeModel::NotifyObserverBeginBatch() { |
1164 // Only notify the model once if we're batching in a nested manner. | 1303 // Only notify the model once if we're batching in a nested manner. |
1165 if (batch_update_++ == 0) { | 1304 if (batch_update_++ == 0) { |
1166 FOR_EACH_OBSERVER(Observer, | 1305 FOR_EACH_OBSERVER(Observer, |
1167 cookies_observer_list_, | 1306 cookies_observer_list_, |
1168 TreeModelBeginBatch(this)); | 1307 TreeModelBeginBatch(this)); |
1169 } | 1308 } |
1170 } | 1309 } |
1171 | 1310 |
1172 void CookiesTreeModel::NotifyObserverEndBatch() { | 1311 void CookiesTreeModel::NotifyObserverEndBatch() { |
1173 // Only notify the observers if this is the outermost call to EndBatch() if | 1312 // Only notify the observers if this is the outermost call to EndBatch() if |
1174 // called in a nested manner. | 1313 // called in a nested manner. |
1175 if (--batch_update_ == 0) { | 1314 if (--batch_update_ == 0) { |
1176 FOR_EACH_OBSERVER(Observer, | 1315 FOR_EACH_OBSERVER(Observer, |
1177 cookies_observer_list_, | 1316 cookies_observer_list_, |
1178 TreeModelEndBatch(this)); | 1317 TreeModelEndBatch(this)); |
1179 } | 1318 } |
1180 } | 1319 } |
1181 | 1320 |
1182 LocalDataContainer* CookiesTreeModel::GetLocalDataContainer( | 1321 LocalDataContainer* CookiesTreeModel::GetLocalDataContainer( |
1183 const std::string& app_id) { | 1322 const std::string& app_id) { |
1184 LocalDataContainer* container = app_data_map_[app_id]; | 1323 LocalDataContainer* container = app_data_map_[app_id]; |
1185 return container; | 1324 return container; |
1186 } | 1325 } |
OLD | NEW |