Fix object ownership in ui/base/models.

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 <stddef.h>
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #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"
 #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_factory.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "content/public/common/url_constants.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/url_request/url_request_context.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/resources/grit/ui_resources.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "extensions/common/extension_set.h"
 #endif
 
 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.
     CHECK_EQ(CookieTreeNode::DetailedInfo::TYPE_HOST,
              lhs->GetDetailedInfo().node_type);
     CHECK_EQ(CookieTreeNode::DetailedInfo::TYPE_HOST,
              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();
   }
 };
 
 std::string CanonicalizeHost(const GURL& url) {
   // The canonicalized representation makes the registry controlled domain
   // come first, and then adds subdomains in reverse order, e.g.
   // 1.mail.google.com would become google.com.mail.1, and then a standard
   // string comparison works to order hosts by registry controlled domain
   // first. Leading dots are ignored, ".google.com" is the same as
   // "google.com".
@@ skipping 189 matching lines @@
     const std::string& flash_lso_domain) {
   Init(TYPE_FLASH_LSO);
   this->flash_lso_domain = flash_lso_domain;
   return *this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, public:
 
 void CookieTreeNode::DeleteStoredObjects() {
-  for (auto* child : children())
+  for (const auto& child : children())
     child->DeleteStoredObjects();
 }
 
 CookiesTreeModel* CookieTreeNode::GetModel() const {
   if (parent())
     return parent()->GetModel();
   return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 288 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(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 {
   return model_;
 }
 
 CookieTreeNode::DetailedInfo CookieTreeRootNode::GetDetailedInfo() const {
   return DetailedInfo().Init(DetailedInfo::TYPE_ROOT);
 }
 
@@ skipping 22 matching lines @@
 }
 
 CookieTreeNode::DetailedInfo CookieTreeHostNode::GetDetailedInfo() const {
   return DetailedInfo().InitHost();
 }
 
 CookieTreeCookiesNode* CookieTreeHostNode::GetOrCreateCookiesNode() {
   if (cookies_child_)
     return cookies_child_;
   cookies_child_ = new CookieTreeCookiesNode;
-  AddChildSortedByTitle(cookies_child_);
+  AddChildSortedByTitle(base::WrapUnique(cookies_child_));
   return cookies_child_;
 }
 
 CookieTreeDatabasesNode* CookieTreeHostNode::GetOrCreateDatabasesNode() {
   if (databases_child_)
     return databases_child_;
   databases_child_ = new CookieTreeDatabasesNode;
-  AddChildSortedByTitle(databases_child_);
+  AddChildSortedByTitle(base::WrapUnique(databases_child_));
   return databases_child_;
 }
 
 CookieTreeLocalStoragesNode*
     CookieTreeHostNode::GetOrCreateLocalStoragesNode() {
   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_;
 }
 
 CookieTreeSessionStoragesNode*
     CookieTreeHostNode::GetOrCreateSessionStoragesNode() {
   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_;
 }
 
 CookieTreeAppCachesNode* CookieTreeHostNode::GetOrCreateAppCachesNode() {
   if (appcaches_child_)
     return appcaches_child_;
   appcaches_child_ = new CookieTreeAppCachesNode;
-  AddChildSortedByTitle(appcaches_child_);
+  AddChildSortedByTitle(base::WrapUnique(appcaches_child_));
   return appcaches_child_;
 }
 
 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_;
 }
 
 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_;
 }
 
 CookieTreeQuotaNode* CookieTreeHostNode::UpdateOrCreateQuotaNode(
     std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) {
   if (quota_child_)
     return quota_child_;
   quota_child_ = new CookieTreeQuotaNode(quota_info);
-  AddChildSortedByTitle(quota_child_);
+  AddChildSortedByTitle(base::WrapUnique(quota_child_));
   return quota_child_;
 }
 
 CookieTreeChannelIDsNode*
 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_;
 }
 
 CookieTreeServiceWorkersNode*
 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_;
 }
 
 CookieTreeCacheStoragesNode*
 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_;
 }
 
 CookieTreeFlashLSONode* CookieTreeHostNode::GetOrCreateFlashLSONode(
     const std::string& domain) {
   DCHECK_EQ(GetHost(), domain);
   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_;
 }
 
 void CookieTreeHostNode::CreateContentException(
     content_settings::CookieSettings* cookie_settings,
     ContentSetting setting) const {
   DCHECK(setting == CONTENT_SETTING_ALLOW ||
          setting == CONTENT_SETTING_BLOCK ||
          setting == CONTENT_SETTING_SESSION_ONLY);
   if (CanCreateContentException()) {
@@ skipping 111 matching lines @@
         l10n_util::GetStringUTF16(IDS_COOKIES_CHANNEL_IDS)) {
 }
 
 CookieTreeChannelIDsNode::~CookieTreeChannelIDsNode() {}
 
 CookieTreeNode::DetailedInfo
 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());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeServiceWorkersNode, public:
 
 CookieTreeServiceWorkersNode::CookieTreeServiceWorkersNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_SERVICE_WORKERS)) {
 }
 
 CookieTreeServiceWorkersNode::~CookieTreeServiceWorkersNode() {
@@ skipping 63 matching lines @@
     model_->NotifyObserverBeginBatch();
     batch_in_progress_ = true;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, public:
 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
       data_container_(data_container) {
   data_container_->Init(this);
 }
 
 CookiesTreeModel::~CookiesTreeModel() {
 }
 
@@ skipping 53 matching lines @@
     default:
       break;
   }
   return -1;
 }
 
 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();
 }
 
 void CookiesTreeModel::DeleteCookieNode(CookieTreeNode* cookie_node) {
   if (cookie_node == GetRoot())
     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);
 }
 
 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);
   PopulateLocalStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateSessionStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateAppCacheInfoWithFilter(data_container(), &notifier, filter);
   PopulateIndexedDBInfoWithFilter(data_container(), &notifier, filter);
   PopulateFileSystemInfoWithFilter(data_container(), &notifier, filter);
   PopulateQuotaInfoWithFilter(data_container(), &notifier, filter);
   PopulateChannelIDInfoWithFilter(data_container(), &notifier, filter);
@@ skipping 111 matching lines @@
     base::string16 host_node_name = base::UTF8ToUTF16(origin.first.host());
     if (filter.empty() ||
         (host_node_name.find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin.first);
       CookieTreeAppCachesNode* appcaches_node =
           host_node->GetOrCreateAppCachesNode();
 
       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));
       }
     }
   }
 }
 
 void CookiesTreeModel::PopulateCookieInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   notifier->StartBatchUpdate();
   for (CookieList::iterator it = container->cookie_list_.begin();
        it != container->cookie_list_.end(); ++it) {
     std::string domain = it->Domain();
     if (domain.length() > 1 && domain[0] == '.')
       domain = domain.substr(1);
 
     // Cookies ignore schemes, so group all HTTP and HTTPS cookies together.
     GURL source(std::string(url::kHttpScheme) + url::kStandardSchemeSeparator +
                 domain + "/");
 
     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);
+      cookies_node->AddCookieNode(base::MakeUnique<CookieTreeCookieNode>(it));
     }
   }
 }
 
 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.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));
+          base::MakeUnique<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.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));
+          base::MakeUnique<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.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));
+          base::MakeUnique<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.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));
+          base::MakeUnique<CookieTreeIndexedDBNode>(indexed_db_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateChannelIDInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
@@ skipping 12 matching lines @@
       origin = GURL(std::string(url::kHttpsScheme) +
           url::kStandardSchemeSeparator +
           channel_id_info->server_identifier() + "/");
     }
     base::string16 title = CookieTreeHostNode::TitleForUrl(origin);
     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));
+          base::MakeUnique<CookieTreeChannelIDNode>(channel_id_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateServiceWorkerUsageInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->service_worker_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (ServiceWorkerUsageInfoList::iterator service_worker_info =
            container->service_worker_info_list_.begin();
        service_worker_info != container->service_worker_info_list_.end();
        ++service_worker_info) {
     const GURL& origin = service_worker_info->origin;
 
     if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
                                .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeServiceWorkersNode* service_workers_node =
           host_node->GetOrCreateServiceWorkersNode();
       service_workers_node->AddServiceWorkerNode(
-          new CookieTreeServiceWorkerNode(service_worker_info));
+          base::MakeUnique<CookieTreeServiceWorkerNode>(service_worker_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateCacheStorageUsageInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->cache_storage_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (CacheStorageUsageInfoList::iterator cache_storage_info =
            container->cache_storage_info_list_.begin();
        cache_storage_info != container->cache_storage_info_list_.end();
        ++cache_storage_info) {
     const GURL& origin = cache_storage_info->origin;
 
     if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
                                .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeCacheStoragesNode* cache_storages_node =
           host_node->GetOrCreateCacheStoragesNode();
       cache_storages_node->AddCacheStorageNode(
-          new CookieTreeCacheStorageNode(cache_storage_info));
+          base::MakeUnique<CookieTreeCacheStorageNode>(cache_storage_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   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.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));
+          base::MakeUnique<CookieTreeFileSystemNode>(file_system_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateQuotaInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
@@ skipping 69 matching lines @@
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (batches_ended_ == batches_started_ &&
       batches_seen_ == batches_expected_) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
     SetBatchExpectation(0, true);
   }
 }