chrome/browser/browsing_data/cookies_tree_model.cc

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