Browsing Data Deletion: Style fixes

chrome/browser/browsing_data/cookies_tree_model.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
+#include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/linked_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_channel_id_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_cookie_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_flash_lso_helper.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
@@ skipping 277 matching lines @@
 CookieTreeCookieNode::CookieTreeCookieNode(
     std::list<net::CanonicalCookie>::iterator cookie)
     : CookieTreeNode(base::UTF8ToUTF16(cookie->Name())),
       cookie_(cookie) {
 }
 
 CookieTreeCookieNode::~CookieTreeCookieNode() {}
 
 void CookieTreeCookieNode::DeleteStoredObjects() {
   LocalDataContainer* container = GetLocalDataContainerForNode(this);
-  CHECK(container);
   container->cookie_helper_->DeleteCookie(*cookie_);
   container->cookie_list_.erase(cookie_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const {
   return DetailedInfo().InitCookie(&*cookie_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeAppCacheNode, public:
@@ skipping 574 matching lines @@
     const std::string& domain)
     : domain_(domain) {}
 CookieTreeFlashLSONode::~CookieTreeFlashLSONode() {}
 
 void CookieTreeFlashLSONode::DeleteStoredObjects() {
   // We are one level below the host node.
   CookieTreeHostNode* host = static_cast<CookieTreeHostNode*>(parent());
   CHECK_EQ(host->GetDetailedInfo().node_type,
            CookieTreeNode::DetailedInfo::TYPE_HOST);
   LocalDataContainer* container = GetModel()->data_container();
-  CHECK(container);
-
   container->flash_lso_helper_->DeleteFlashLSOsForSite(domain_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeFlashLSONode::GetDetailedInfo() const {
   return DetailedInfo().InitFlashLSO(domain_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ScopedBatchUpdateNotifier
 CookiesTreeModel::ScopedBatchUpdateNotifier::ScopedBatchUpdateNotifier(
@@ skipping 256 matching lines @@
       std::string domain = it->Domain();
       if (domain.length() > 1 && domain[0] == '.')
         domain = domain.substr(1);
 
       // We treat secure cookies just the same as normal ones.
       source_string = std::string(url::kHttpScheme) +
           url::kStandardSchemeSeparator + domain + "/";
     }
 
     GURL source(source_string);
-    if (!filter.size() ||
-        (CookieTreeHostNode::TitleForUrl(source).find(filter) !=
-        base::string16::npos)) {
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(source)
+                               .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(source);
       CookieTreeCookiesNode* cookies_node =
           host_node->GetOrCreateCookiesNode();
       CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it);
       cookies_node->AddCookieNode(new_cookie);
     }
   }
 }
 
 void CookiesTreeModel::PopulateDatabaseInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->database_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (DatabaseInfoList::iterator database_info =
            container->database_info_list_.begin();
        database_info != container->database_info_list_.end();
        ++database_info) {
     GURL origin(database_info->identifier.ToOrigin());
 
-    if (!filter.size() ||
-        (CookieTreeHostNode::TitleForUrl(origin).find(filter) !=
-        base::string16::npos)) {
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
+                               .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeDatabasesNode* databases_node =
           host_node->GetOrCreateDatabasesNode();
       databases_node->AddDatabaseNode(
           new CookieTreeDatabaseNode(database_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateLocalStorageInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->local_storage_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (LocalStorageInfoList::iterator local_storage_info =
            container->local_storage_info_list_.begin();
        local_storage_info != container->local_storage_info_list_.end();
        ++local_storage_info) {
     const GURL& origin(local_storage_info->origin_url);
 
-    if (!filter.size() ||
-        (CookieTreeHostNode::TitleForUrl(origin).find(filter) !=
-        std::string::npos)) {
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
+                               .find(filter) != std::string::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeLocalStoragesNode* local_storages_node =
           host_node->GetOrCreateLocalStoragesNode();
       local_storages_node->AddLocalStorageNode(
           new CookieTreeLocalStorageNode(local_storage_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateSessionStorageInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->session_storage_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (LocalStorageInfoList::iterator session_storage_info =
            container->session_storage_info_list_.begin();
        session_storage_info != container->session_storage_info_list_.end();
        ++session_storage_info) {
     const GURL& origin = session_storage_info->origin_url;
 
-    if (!filter.size() ||
-        (CookieTreeHostNode::TitleForUrl(origin).find(filter) !=
-        base::string16::npos)) {
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
+                               .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeSessionStoragesNode* session_storages_node =
           host_node->GetOrCreateSessionStoragesNode();
       session_storages_node->AddSessionStorageNode(
           new CookieTreeSessionStorageNode(session_storage_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateIndexedDBInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->indexed_db_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (IndexedDBInfoList::iterator indexed_db_info =
            container->indexed_db_info_list_.begin();
        indexed_db_info != container->indexed_db_info_list_.end();
        ++indexed_db_info) {
     const GURL& origin = indexed_db_info->origin_;
 
-    if (!filter.size() ||
-        (CookieTreeHostNode::TitleForUrl(origin).find(filter) !=
-        base::string16::npos)) {
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
+                               .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeIndexedDBsNode* indexed_dbs_node =
           host_node->GetOrCreateIndexedDBsNode();
       indexed_dbs_node->AddIndexedDBNode(
           new CookieTreeIndexedDBNode(indexed_db_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateChannelIDInfoWithFilter(
@@ skipping 12 matching lines @@
        ++channel_id_info) {
     GURL origin(channel_id_info->server_identifier());
     if (!origin.is_valid()) {
       // Channel ID.  Make a valid URL to satisfy the
       // CookieTreeRootNode::GetOrCreateHostNode interface.
       origin = GURL(std::string(url::kHttpsScheme) +
           url::kStandardSchemeSeparator +
           channel_id_info->server_identifier() + "/");
     }
     base::string16 title = CookieTreeHostNode::TitleForUrl(origin);
-    if (!filter.size() || title.find(filter) != base::string16::npos) {
+    if (filter.empty() || title.find(filter) != base::string16::npos) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeChannelIDsNode* channel_ids_node =
           host_node->GetOrCreateChannelIDsNode();
       channel_ids_node->AddChannelIDNode(
           new CookieTreeChannelIDNode(channel_id_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateServiceWorkerUsageInfoWithFilter(
@@ skipping 32 matching lines @@
   if (container->file_system_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (FileSystemInfoList::iterator file_system_info =
            container->file_system_info_list_.begin();
        file_system_info != container->file_system_info_list_.end();
        ++file_system_info) {
     GURL origin(file_system_info->origin);
 
-    if (!filter.size() ||
-        (CookieTreeHostNode::TitleForUrl(origin).find(filter) !=
-        base::string16::npos)) {
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
+                               .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeFileSystemsNode* file_systems_node =
           host_node->GetOrCreateFileSystemsNode();
       file_systems_node->AddFileSystemNode(
           new CookieTreeFileSystemNode(file_system_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateQuotaInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->quota_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (QuotaInfoList::iterator quota_info = container->quota_info_list_.begin();
        quota_info != container->quota_info_list_.end();
        ++quota_info) {
-    if (!filter.size() ||
-        (base::UTF8ToUTF16(quota_info->host).find(filter) !=
-            base::string16::npos)) {
+    if (filter.empty() || (base::UTF8ToUTF16(quota_info->host).find(filter) !=
+                           base::string16::npos)) {
       CookieTreeHostNode* host_node =
           root->GetOrCreateHostNode(GURL("http://" + quota_info->host));
       host_node->UpdateOrCreateQuotaNode(quota_info);
     }
   }
 }
 
 void CookiesTreeModel::PopulateFlashLSOInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->flash_lso_domain_list_.empty())
     return;
 
   std::string filter_utf8 = base::UTF16ToUTF8(filter);
   notifier->StartBatchUpdate();
   for (std::vector<std::string>::iterator it =
            container->flash_lso_domain_list_.begin();
        it != container->flash_lso_domain_list_.end(); ++it) {
-    if (!filter_utf8.size() || it->find(filter_utf8) != std::string::npos) {
+    if (filter_utf8.empty() || it->find(filter_utf8) != std::string::npos) {
       // Create a fake origin for GetOrCreateHostNode().
       GURL origin("http://" + *it);
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       host_node->GetOrCreateFlashLSONode(*it);
     }
   }
 }
 
 void CookiesTreeModel::NotifyObserverBeginBatch() {
   // Only notify the model once if we're batching in a nested manner.
   if (batch_update_++ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelBeginBatch(this));
   }
 }
 
 void CookiesTreeModel::NotifyObserverEndBatch() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (--batch_update_ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }