Replace string16 with base::string16.

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 <vector>
 
@@ skipping 920 matching lines @@
 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);
   if (parent_node->empty())
     DeleteCookieNode(parent_node);
 }
 
-void CookiesTreeModel::UpdateSearchResults(const string16& filter) {
+void CookiesTreeModel::UpdateSearchResults(const base::string16& filter) {
   CookieTreeNode* root = GetRoot();
   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));
 
   PopulateCookieInfoWithFilter(data_container(), &notifier, filter);
   PopulateDatabaseInfoWithFilter(data_container(), &notifier, filter);
   PopulateLocalStorageInfoWithFilter(data_container(), &notifier, filter);
@@ skipping 26 matching lines @@
 }
 
 void CookiesTreeModel::RemoveCookiesTreeObserver(Observer* observer) {
   cookies_observer_list_.RemoveObserver(observer);
   // Call super so that TreeNodeModel doesn't have dead pointers.
   ui::TreeNodeModel<CookieTreeNode>::RemoveObserver(observer);
 }
 
 void CookiesTreeModel::PopulateAppCacheInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateAppCacheInfoWithFilter(container, &notifier, string16());
+  PopulateAppCacheInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateCookieInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateCookieInfoWithFilter(container, &notifier, string16());
+  PopulateCookieInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateDatabaseInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateDatabaseInfoWithFilter(container, &notifier, string16());
+  PopulateDatabaseInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateLocalStorageInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateLocalStorageInfoWithFilter(container, &notifier, string16());
+  PopulateLocalStorageInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateSessionStorageInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateSessionStorageInfoWithFilter(container, &notifier, string16());
+  PopulateSessionStorageInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateIndexedDBInfo(LocalDataContainer* container){
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateIndexedDBInfoWithFilter(container, &notifier, string16());
+  PopulateIndexedDBInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateFileSystemInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateFileSystemInfoWithFilter(container, &notifier, string16());
+  PopulateFileSystemInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateQuotaInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateQuotaInfoWithFilter(container, &notifier, string16());
+  PopulateQuotaInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateServerBoundCertInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateServerBoundCertInfoWithFilter(container, &notifier, string16());
+  PopulateServerBoundCertInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateFlashLSOInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateFlashLSOInfoWithFilter(container, &notifier, string16());
+  PopulateFlashLSOInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
-    const string16& filter) {
+    const base::string16& filter) {
   using appcache::AppCacheInfo;
   typedef std::map<GURL, std::list<AppCacheInfo> > InfoByOrigin;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->appcache_info_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (InfoByOrigin::iterator origin = container->appcache_info_.begin();
        origin != container->appcache_info_.end(); ++origin) {
-    string16 host_node_name = UTF8ToUTF16(origin->first.host());
+    base::string16 host_node_name = UTF8ToUTF16(origin->first.host());
     if (filter.empty() ||
-        (host_node_name.find(filter) != string16::npos)) {
+        (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));
       }
     }
   }
 }
 
 void CookiesTreeModel::PopulateCookieInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
-    const string16& filter) {
+    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 source_string = it->Source();
     if (source_string.empty() || !group_by_cookie_source_) {
       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(content::kHttpScheme) +
           content::kStandardSchemeSeparator + domain + "/";
     }
 
     GURL source(source_string);
     if (!filter.size() ||
         (CookieTreeHostNode::TitleForUrl(source).find(filter) !=
-        string16::npos)) {
+        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 string16& filter) {
+    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) !=
-        string16::npos)) {
+        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 string16& filter) {
+    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)) {
       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 string16& filter) {
+    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) !=
-        string16::npos)) {
+        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 string16& filter) {
+    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) !=
-        string16::npos)) {
+        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::PopulateServerBoundCertInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
-    const string16& filter) {
+    const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->server_bound_cert_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
   for (ServerBoundCertList::iterator cert_info =
            container->server_bound_cert_list_.begin();
        cert_info != container->server_bound_cert_list_.end();
        ++cert_info) {
     GURL origin(cert_info->server_identifier());
     if (!origin.is_valid()) {
       // Domain Bound Cert.  Make a valid URL to satisfy the
       // CookieTreeRootNode::GetOrCreateHostNode interface.
       origin = GURL(std::string(content::kHttpsScheme) +
           content::kStandardSchemeSeparator +
           cert_info->server_identifier() + "/");
     }
-    string16 title = CookieTreeHostNode::TitleForUrl(origin);
-    if (!filter.size() || title.find(filter) != string16::npos) {
+    base::string16 title = CookieTreeHostNode::TitleForUrl(origin);
+    if (!filter.size() || title.find(filter) != base::string16::npos) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeServerBoundCertsNode* server_bound_certs_node =
           host_node->GetOrCreateServerBoundCertsNode();
       server_bound_certs_node->AddServerBoundCertNode(
           new CookieTreeServerBoundCertNode(cert_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
-    const string16& filter) {
+    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.size() ||
         (CookieTreeHostNode::TitleForUrl(origin).find(filter) !=
-        string16::npos)) {
+        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 string16& filter) {
+    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() ||
-        (UTF8ToUTF16(quota_info->host).find(filter) != string16::npos)) {
+        (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 string16& filter) {
+    const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->flash_lso_domain_list_.empty())
     return;
 
   std::string filter_utf8 = 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) {
@@ skipping 17 matching lines @@
 
 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));
   }
 }