Fix object ownership in ui/base/models.

chrome/browser/browsing_data/cookies_tree_model.cc

Index: chrome/browser/browsing_data/cookies_tree_model.cc
diff --git a/chrome/browser/browsing_data/cookies_tree_model.cc b/chrome/browser/browsing_data/cookies_tree_model.cc
index ad13ac3f22229eb315e09afc6c44515196ed6d8b..5c52e11ffed4ef092882e081a6288a73acfd8033 100644
--- a/chrome/browser/browsing_data/cookies_tree_model.cc
+++ b/chrome/browser/browsing_data/cookies_tree_model.cc
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/memory/linked_ptr.h"
+#include "base/memory/ptr_util.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"
@@ -39,14 +39,16 @@
 namespace {
 
 struct NodeTitleComparator {
-  bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) {
+  bool operator()(const std::unique_ptr<CookieTreeNode>& lhs,
+                  const std::unique_ptr<CookieTreeNode>& rhs) {
     return lhs->GetTitle() < rhs->GetTitle();
   }
 };
 
 // Comparison functor, for use in CookieTreeRootNode.
 struct HostNodeComparator {
-  bool operator()(const CookieTreeNode* lhs, const CookieTreeNode* rhs) {
+  bool operator()(const std::unique_ptr<CookieTreeNode>& lhs,
+                  const std::unique_ptr<CookieTreeHostNode>& rhs) {
     // This comparator is only meant to compare CookieTreeHostNode types. Make
     // sure we check this, as the static cast below is dangerous if we get the
     // wrong object type.
@@ -56,16 +58,14 @@ struct HostNodeComparator {
              rhs->GetDetailedInfo().node_type);
 
     const CookieTreeHostNode* ltn =
-        static_cast<const CookieTreeHostNode*>(lhs);
-    const CookieTreeHostNode* rtn =
-        static_cast<const CookieTreeHostNode*>(rhs);
+        static_cast<const CookieTreeHostNode*>(lhs.get());
+    const CookieTreeHostNode* rtn = rhs.get();
 
     // We want to order by registry controlled domain, so we would get
     // google.com, ad.google.com, www.google.com,
     // microsoft.com, ad.microsoft.com. CanonicalizeHost transforms the origins
     // into a form like google.com.www so that string comparisons work.
-    return (ltn->canonicalized_host() <
-            rtn->canonicalized_host());
+    return ltn->canonicalized_host() < rtn->canonicalized_host();
   }
 };
 
@@ -275,7 +275,7 @@ CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitFlashLSO(
 // CookieTreeNode, public:
 
 void CookieTreeNode::DeleteStoredObjects() {
-  for (auto* child : children())
+  for (const auto& child : children())
     child->DeleteStoredObjects();
 }
 
@@ -584,21 +584,20 @@ CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
 CookieTreeRootNode::~CookieTreeRootNode() {}
 
 CookieTreeHostNode* CookieTreeRootNode::GetOrCreateHostNode(const GURL& url) {
-  std::unique_ptr<CookieTreeHostNode> host_node(new CookieTreeHostNode(url));
+  std::unique_ptr<CookieTreeHostNode> host_node =
+      base::MakeUnique<CookieTreeHostNode>(url);
 
   // First see if there is an existing match.
-  std::vector<CookieTreeNode*>::iterator host_node_iterator =
-        std::lower_bound(children().begin(), children().end(), host_node.get(),
-                         HostNodeComparator());
+  auto host_node_iterator = std::lower_bound(
+      children().begin(), children().end(), host_node, HostNodeComparator());
   if (host_node_iterator != children().end() &&
       CookieTreeHostNode::TitleForUrl(url) ==
       (*host_node_iterator)->GetTitle())
-    return static_cast<CookieTreeHostNode*>(*host_node_iterator);
+    return static_cast<CookieTreeHostNode*>(host_node_iterator->get());
   // Node doesn't exist, insert the new one into the (ordered) children.
   DCHECK(model_);
-  model_->Add(this, host_node.get(),
-              (host_node_iterator - children().begin()));
-  return host_node.release();
+  return static_cast<CookieTreeHostNode*>(model_->Add(
+      this, std::move(host_node), (host_node_iterator - children().begin())));
 }
 
 CookiesTreeModel* CookieTreeRootNode::GetModel() const {
@@ -641,7 +640,7 @@ CookieTreeCookiesNode* CookieTreeHostNode::GetOrCreateCookiesNode() {
   if (cookies_child_)
     return cookies_child_;
   cookies_child_ = new CookieTreeCookiesNode;
-  AddChildSortedByTitle(cookies_child_);
+  AddChildSortedByTitle(base::WrapUnique(cookies_child_));
   return cookies_child_;
 }
 
@@ -649,7 +648,7 @@ CookieTreeDatabasesNode* CookieTreeHostNode::GetOrCreateDatabasesNode() {
   if (databases_child_)
     return databases_child_;
   databases_child_ = new CookieTreeDatabasesNode;
-  AddChildSortedByTitle(databases_child_);
+  AddChildSortedByTitle(base::WrapUnique(databases_child_));
   return databases_child_;
 }
 
@@ -658,7 +657,7 @@ CookieTreeLocalStoragesNode*
   if (local_storages_child_)
     return local_storages_child_;
   local_storages_child_ = new CookieTreeLocalStoragesNode;
-  AddChildSortedByTitle(local_storages_child_);
+  AddChildSortedByTitle(base::WrapUnique(local_storages_child_));
   return local_storages_child_;
 }
 
@@ -667,7 +666,7 @@ CookieTreeSessionStoragesNode*
   if (session_storages_child_)
     return session_storages_child_;
   session_storages_child_ = new CookieTreeSessionStoragesNode;
-  AddChildSortedByTitle(session_storages_child_);
+  AddChildSortedByTitle(base::WrapUnique(session_storages_child_));
   return session_storages_child_;
 }
 
@@ -675,7 +674,7 @@ CookieTreeAppCachesNode* CookieTreeHostNode::GetOrCreateAppCachesNode() {
   if (appcaches_child_)
     return appcaches_child_;
   appcaches_child_ = new CookieTreeAppCachesNode;
-  AddChildSortedByTitle(appcaches_child_);
+  AddChildSortedByTitle(base::WrapUnique(appcaches_child_));
   return appcaches_child_;
 }
 
@@ -683,7 +682,7 @@ CookieTreeIndexedDBsNode* CookieTreeHostNode::GetOrCreateIndexedDBsNode() {
   if (indexed_dbs_child_)
     return indexed_dbs_child_;
   indexed_dbs_child_ = new CookieTreeIndexedDBsNode;
-  AddChildSortedByTitle(indexed_dbs_child_);
+  AddChildSortedByTitle(base::WrapUnique(indexed_dbs_child_));
   return indexed_dbs_child_;
 }
 
@@ -691,7 +690,7 @@ CookieTreeFileSystemsNode* CookieTreeHostNode::GetOrCreateFileSystemsNode() {
   if (file_systems_child_)
     return file_systems_child_;
   file_systems_child_ = new CookieTreeFileSystemsNode;
-  AddChildSortedByTitle(file_systems_child_);
+  AddChildSortedByTitle(base::WrapUnique(file_systems_child_));
   return file_systems_child_;
 }
 
@@ -700,7 +699,7 @@ CookieTreeQuotaNode* CookieTreeHostNode::UpdateOrCreateQuotaNode(
   if (quota_child_)
     return quota_child_;
   quota_child_ = new CookieTreeQuotaNode(quota_info);
-  AddChildSortedByTitle(quota_child_);
+  AddChildSortedByTitle(base::WrapUnique(quota_child_));
   return quota_child_;
 }
 
@@ -709,7 +708,7 @@ CookieTreeHostNode::GetOrCreateChannelIDsNode() {
   if (channel_ids_child_)
     return channel_ids_child_;
   channel_ids_child_ = new CookieTreeChannelIDsNode;
-  AddChildSortedByTitle(channel_ids_child_);
+  AddChildSortedByTitle(base::WrapUnique(channel_ids_child_));
   return channel_ids_child_;
 }
 
@@ -718,7 +717,7 @@ CookieTreeHostNode::GetOrCreateServiceWorkersNode() {
   if (service_workers_child_)
     return service_workers_child_;
   service_workers_child_ = new CookieTreeServiceWorkersNode;
-  AddChildSortedByTitle(service_workers_child_);
+  AddChildSortedByTitle(base::WrapUnique(service_workers_child_));
   return service_workers_child_;
 }
 
@@ -727,7 +726,7 @@ CookieTreeHostNode::GetOrCreateCacheStoragesNode() {
   if (cache_storages_child_)
     return cache_storages_child_;
   cache_storages_child_ = new CookieTreeCacheStoragesNode;
-  AddChildSortedByTitle(cache_storages_child_);
+  AddChildSortedByTitle(base::WrapUnique(cache_storages_child_));
   return cache_storages_child_;
 }
 
@@ -737,7 +736,7 @@ CookieTreeFlashLSONode* CookieTreeHostNode::GetOrCreateFlashLSONode(
   if (flash_lso_child_)
     return flash_lso_child_;
   flash_lso_child_ = new CookieTreeFlashLSONode(domain);
-  AddChildSortedByTitle(flash_lso_child_);
+  AddChildSortedByTitle(base::WrapUnique(flash_lso_child_));
   return flash_lso_child_;
 }
 
@@ -869,12 +868,12 @@ CookieTreeChannelIDsNode::GetDetailedInfo() const {
   return DetailedInfo().Init(DetailedInfo::TYPE_CHANNEL_IDS);
 }
 
-void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) {
+void CookieTreeNode::AddChildSortedByTitle(
+    std::unique_ptr<CookieTreeNode> new_child) {
   DCHECK(new_child);
-  std::vector<CookieTreeNode*>::iterator iter =
-      std::lower_bound(children().begin(), children().end(), new_child,
-                       NodeTitleComparator());
-  GetModel()->Add(this, new_child, iter - children().begin());
+  auto iter = std::lower_bound(children().begin(), children().end(), new_child,
+                               NodeTitleComparator());
+  GetModel()->Add(this, std::move(new_child), iter - children().begin());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -958,7 +957,8 @@ void CookiesTreeModel::ScopedBatchUpdateNotifier::StartBatchUpdate() {
 CookiesTreeModel::CookiesTreeModel(
     LocalDataContainer* data_container,
     ExtensionSpecialStoragePolicy* special_storage_policy)
-    : ui::TreeNodeModel<CookieTreeNode>(new CookieTreeRootNode(this)),
+    : ui::TreeNodeModel<CookieTreeNode>(
+          base::MakeUnique<CookieTreeRootNode>(this)),
 #if defined(ENABLE_EXTENSIONS)
       special_storage_policy_(special_storage_policy),
 #endif
@@ -1032,9 +1032,7 @@ void CookiesTreeModel::DeleteAllStoredObjects() {
   NotifyObserverBeginBatch();
   CookieTreeNode* root = GetRoot();
   root->DeleteStoredObjects();
-  int num_children = root->child_count();
-  for (int i = num_children - 1; i >= 0; --i)
-    delete Remove(root, root->GetChild(i));
+  root->DeleteAll();
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
@@ -1044,7 +1042,7 @@ void CookiesTreeModel::DeleteCookieNode(CookieTreeNode* cookie_node) {
     return;
   cookie_node->DeleteStoredObjects();
   CookieTreeNode* parent_node = cookie_node->parent();
-  delete Remove(parent_node, cookie_node);
+  Remove(parent_node, cookie_node);
   if (parent_node->empty())
     DeleteCookieNode(parent_node);
 }
@@ -1053,10 +1051,8 @@ void CookiesTreeModel::UpdateSearchResults(const base::string16& filter) {
   CookieTreeNode* root = GetRoot();
   SetBatchExpectation(1, true);
   ScopedBatchUpdateNotifier notifier(this, root);
-  int num_children = root->child_count();
   notifier.StartBatchUpdate();
-  for (int i = num_children - 1; i >= 0; --i)
-    delete Remove(root, root->GetChild(i));
+  root->DeleteAll();
 
   PopulateCookieInfoWithFilter(data_container(), &notifier, filter);
   PopulateDatabaseInfoWithFilter(data_container(), &notifier, filter);
@@ -1188,7 +1184,7 @@ void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
       for (std::list<AppCacheInfo>::iterator info = origin.second.begin();
            info != origin.second.end(); ++info) {
         appcaches_node->AddAppCacheNode(
-            new CookieTreeAppCacheNode(origin.first, info));
+            base::MakeUnique<CookieTreeAppCacheNode>(origin.first, info));
       }
     }
   }
@@ -1216,8 +1212,7 @@ void CookiesTreeModel::PopulateCookieInfoWithFilter(
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(source);
       CookieTreeCookiesNode* cookies_node =
           host_node->GetOrCreateCookiesNode();
-      CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it);
-      cookies_node->AddCookieNode(new_cookie);
+      cookies_node->AddCookieNode(base::MakeUnique<CookieTreeCookieNode>(it));
     }
   }
 }
@@ -1244,7 +1239,7 @@ void CookiesTreeModel::PopulateDatabaseInfoWithFilter(
       CookieTreeDatabasesNode* databases_node =
           host_node->GetOrCreateDatabasesNode();
       databases_node->AddDatabaseNode(
-          new CookieTreeDatabaseNode(database_info));
+          base::MakeUnique<CookieTreeDatabaseNode>(database_info));
     }
   }
 }
@@ -1271,7 +1266,7 @@ void CookiesTreeModel::PopulateLocalStorageInfoWithFilter(
       CookieTreeLocalStoragesNode* local_storages_node =
           host_node->GetOrCreateLocalStoragesNode();
       local_storages_node->AddLocalStorageNode(
-          new CookieTreeLocalStorageNode(local_storage_info));
+          base::MakeUnique<CookieTreeLocalStorageNode>(local_storage_info));
     }
   }
 }
@@ -1298,7 +1293,7 @@ void CookiesTreeModel::PopulateSessionStorageInfoWithFilter(
       CookieTreeSessionStoragesNode* session_storages_node =
           host_node->GetOrCreateSessionStoragesNode();
       session_storages_node->AddSessionStorageNode(
-          new CookieTreeSessionStorageNode(session_storage_info));
+          base::MakeUnique<CookieTreeSessionStorageNode>(session_storage_info));
     }
   }
 }
@@ -1325,7 +1320,7 @@ void CookiesTreeModel::PopulateIndexedDBInfoWithFilter(
       CookieTreeIndexedDBsNode* indexed_dbs_node =
           host_node->GetOrCreateIndexedDBsNode();
       indexed_dbs_node->AddIndexedDBNode(
-          new CookieTreeIndexedDBNode(indexed_db_info));
+          base::MakeUnique<CookieTreeIndexedDBNode>(indexed_db_info));
     }
   }
 }
@@ -1358,7 +1353,7 @@ void CookiesTreeModel::PopulateChannelIDInfoWithFilter(
       CookieTreeChannelIDsNode* channel_ids_node =
           host_node->GetOrCreateChannelIDsNode();
       channel_ids_node->AddChannelIDNode(
-          new CookieTreeChannelIDNode(channel_id_info));
+          base::MakeUnique<CookieTreeChannelIDNode>(channel_id_info));
     }
   }
 }
@@ -1385,7 +1380,7 @@ void CookiesTreeModel::PopulateServiceWorkerUsageInfoWithFilter(
       CookieTreeServiceWorkersNode* service_workers_node =
           host_node->GetOrCreateServiceWorkersNode();
       service_workers_node->AddServiceWorkerNode(
-          new CookieTreeServiceWorkerNode(service_worker_info));
+          base::MakeUnique<CookieTreeServiceWorkerNode>(service_worker_info));
     }
   }
 }
@@ -1412,7 +1407,7 @@ void CookiesTreeModel::PopulateCacheStorageUsageInfoWithFilter(
       CookieTreeCacheStoragesNode* cache_storages_node =
           host_node->GetOrCreateCacheStoragesNode();
       cache_storages_node->AddCacheStorageNode(
-          new CookieTreeCacheStorageNode(cache_storage_info));
+          base::MakeUnique<CookieTreeCacheStorageNode>(cache_storage_info));
     }
   }
 }
@@ -1439,7 +1434,7 @@ void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
       CookieTreeFileSystemsNode* file_systems_node =
           host_node->GetOrCreateFileSystemsNode();
       file_systems_node->AddFileSystemNode(
-          new CookieTreeFileSystemNode(file_system_info));
+          base::MakeUnique<CookieTreeFileSystemNode>(file_system_info));
     }
   }
 }