Replace string16 with base::string16.

chrome/browser/bookmarks/bookmark_model_unittest.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/bookmarks/bookmark_model.h"
 
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
@@ skipping 290 matching lines @@
   EXPECT_EQ(0, mobile_node->child_count());
   EXPECT_EQ(BookmarkNode::MOBILE, mobile_node->type());
 
   EXPECT_TRUE(bb_node->id() != other_node->id());
   EXPECT_TRUE(bb_node->id() != mobile_node->id());
   EXPECT_TRUE(other_node->id() != mobile_node->id());
 }
 
 TEST_F(BookmarkModelTest, AddURL) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model_.AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
   ASSERT_TRUE(new_node == model_.GetMostRecentlyAddedNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_.other_node()->id() &&
               new_node->id() != model_.mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddURLWithUnicodeTitle) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(WideToUTF16(
+  const base::string16 title(WideToUTF16(
       L"\u767e\u5ea6\u4e00\u4e0b\uff0c\u4f60\u5c31\u77e5\u9053"));
   const GURL url("https://www.baidu.com/");
 
   const BookmarkNode* new_node = model_.AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
   ASSERT_TRUE(new_node == model_.GetMostRecentlyAddedNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_.other_node()->id() &&
               new_node->id() != model_.mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddURLWithWhitespaceTitle) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_whitespace_test_cases); ++i) {
     const BookmarkNode* root = model_.bookmark_bar_node();
-    const string16 title(
+    const base::string16 title(
         ASCIIToUTF16(url_whitespace_test_cases[i].input_title));
     const GURL url("http://foo.com");
 
     const BookmarkNode* new_node = model_.AddURL(root, i, title, url);
 
     int size = i + 1;
     EXPECT_EQ(size, root->child_count());
     EXPECT_EQ(ASCIIToUTF16(url_whitespace_test_cases[i].expected_title),
               new_node->GetTitle());
     EXPECT_EQ(BookmarkNode::URL, new_node->type());
   }
 }
 
 TEST_F(BookmarkModelTest, AddURLToMobileBookmarks) {
   const BookmarkNode* root = model_.mobile_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   const BookmarkNode* new_node = model_.AddURL(root, 0, title, url);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_TRUE(url == new_node->url());
   ASSERT_EQ(BookmarkNode::URL, new_node->type());
   ASSERT_TRUE(new_node == model_.GetMostRecentlyAddedNodeForURL(url));
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_.other_node()->id() &&
               new_node->id() != model_.mobile_node()->id());
 }
 
 TEST_F(BookmarkModelTest, AddFolder) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
 
   const BookmarkNode* new_node = model_.AddFolder(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   ASSERT_EQ(1, root->child_count());
   ASSERT_EQ(title, new_node->GetTitle());
   ASSERT_EQ(BookmarkNode::FOLDER, new_node->type());
 
   EXPECT_TRUE(new_node->id() != root->id() &&
               new_node->id() != model_.other_node()->id() &&
               new_node->id() != model_.mobile_node()->id());
 
   // Add another folder, just to make sure folder_ids are incremented correctly.
   ClearCounts();
   model_.AddFolder(root, 0, title);
   AssertObserverCount(1, 0, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 }
 
 TEST_F(BookmarkModelTest, AddFolderWithWhitespaceTitle) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(title_whitespace_test_cases); ++i) {
     const BookmarkNode* root = model_.bookmark_bar_node();
-    const string16 title(
+    const base::string16 title(
         ASCIIToUTF16(title_whitespace_test_cases[i].input_title));
 
     const BookmarkNode* new_node = model_.AddFolder(root, i, title);
 
     int size = i + 1;
     EXPECT_EQ(size, root->child_count());
     EXPECT_EQ(ASCIIToUTF16(title_whitespace_test_cases[i].expected_title),
               new_node->GetTitle());
     EXPECT_EQ(BookmarkNode::FOLDER, new_node->type());
   }
 }
 
 TEST_F(BookmarkModelTest, RemoveURL) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   model_.AddURL(root, 0, title, url);
   ClearCounts();
 
   model_.Remove(root, 0);
   ASSERT_EQ(0, root->child_count());
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   // Make sure there is no mapping for the URL.
   ASSERT_TRUE(model_.GetMostRecentlyAddedNodeForURL(url) == NULL);
 }
 
 TEST_F(BookmarkModelTest, RemoveFolder) {
   const BookmarkNode* root = model_.bookmark_bar_node();
   const BookmarkNode* folder = model_.AddFolder(root, 0, ASCIIToUTF16("foo"));
 
   ClearCounts();
 
   // Add a URL as a child.
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   model_.AddURL(folder, 0, title, url);
 
   ClearCounts();
 
   // Now remove the folder.
   model_.Remove(root, 0);
   ASSERT_EQ(0, root->child_count());
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
 
   // Make sure there is no mapping for the URL.
   ASSERT_TRUE(model_.GetMostRecentlyAddedNodeForURL(url) == NULL);
 }
 
 TEST_F(BookmarkModelTest, RemoveAll) {
   const BookmarkNode* bookmark_bar_node = model_.bookmark_bar_node();
 
   ClearCounts();
 
   // Add a url to bookmark bar.
-  string16 title(ASCIIToUTF16("foo"));
+  base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
   model_.AddURL(bookmark_bar_node, 0, title, url);
 
   // Add a folder with child URL.
   const BookmarkNode* folder = model_.AddFolder(bookmark_bar_node, 0, title);
   model_.AddURL(folder, 0, title, url);
 
   AssertObserverCount(3, 0, 0, 0, 0, 0, 0, 0, 0);
   ClearCounts();
 
   model_.RemoveAll();
 
   EXPECT_EQ(0, bookmark_bar_node->child_count());
   // No individual BookmarkNodeRemoved events are fired, so removed count
   // should be 0.
   AssertObserverCount(0, 0, 0, 0, 0, 0, 0, 0, 1);
   AssertExtensiveChangesObserverCount(1, 1);
   EXPECT_EQ(1, AllNodesRemovedObserverCount());
 }
 
 TEST_F(BookmarkModelTest, SetTitle) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  string16 title(ASCIIToUTF16("foo"));
+  base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   const BookmarkNode* node = model_.AddURL(root, 0, title, url);
 
   ClearCounts();
 
   title = ASCIIToUTF16("foo2");
   model_.SetTitle(node, title);
   AssertObserverCount(0, 0, 0, 1, 0, 0, 1, 0, 0);
   observer_details_.ExpectEquals(node, NULL, -1, -1);
   EXPECT_EQ(title, node->GetTitle());
 }
 
 TEST_F(BookmarkModelTest, SetTitleWithWhitespace) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(title_whitespace_test_cases); ++i) {
     const BookmarkNode* root = model_.bookmark_bar_node();
-    string16 title(ASCIIToUTF16("dummy"));
+    base::string16 title(ASCIIToUTF16("dummy"));
     const GURL url("http://foo.com");
     const BookmarkNode* node = model_.AddURL(root, 0, title, url);
 
     title = ASCIIToUTF16(title_whitespace_test_cases[i].input_title);
     model_.SetTitle(node, title);
     EXPECT_EQ(ASCIIToUTF16(title_whitespace_test_cases[i].expected_title),
               node->GetTitle());
   }
 }
 
 TEST_F(BookmarkModelTest, SetURL) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
   const BookmarkNode* node = model_.AddURL(root, 0, title, url);
 
   ClearCounts();
 
   url = GURL("http://foo2.com");
   model_.SetURL(node, url);
   AssertObserverCount(0, 0, 0, 1, 0, 0, 1, 0, 0);
   observer_details_.ExpectEquals(node, NULL, -1, -1);
   EXPECT_EQ(url, node->url());
 }
 
 TEST_F(BookmarkModelTest, SetDateAdded) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   GURL url("http://foo.com");
   const BookmarkNode* node = model_.AddURL(root, 0, title, url);
 
   ClearCounts();
 
   base::Time new_time = base::Time::Now() + base::TimeDelta::FromMinutes(20);
   model_.SetDateAdded(node, new_time);
   AssertObserverCount(0, 0, 0, 0, 0, 0, 0, 0, 0);
   EXPECT_EQ(new_time, node->date_added());
   EXPECT_EQ(new_time, model_.bookmark_bar_node()->date_folder_modified());
 }
 
 TEST_F(BookmarkModelTest, Move) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   const BookmarkNode* node = model_.AddURL(root, 0, title, url);
   const BookmarkNode* folder1 = model_.AddFolder(root, 0, ASCIIToUTF16("foo"));
   ClearCounts();
 
   model_.Move(node, folder1, 0);
 
   AssertObserverCount(0, 1, 0, 0, 0, 0, 0, 0, 0);
   observer_details_.ExpectEquals(root, folder1, 1, 0);
   EXPECT_TRUE(folder1 == node->parent());
   EXPECT_EQ(1, root->child_count());
   EXPECT_EQ(folder1, root->GetChild(0));
   EXPECT_EQ(1, folder1->child_count());
   EXPECT_EQ(node, folder1->GetChild(0));
 
   // And remove the folder.
   ClearCounts();
   model_.Remove(root, 0);
   AssertObserverCount(0, 0, 1, 0, 0, 1, 0, 0, 0);
   observer_details_.ExpectEquals(root, NULL, 0, -1);
   EXPECT_TRUE(model_.GetMostRecentlyAddedNodeForURL(url) == NULL);
   EXPECT_EQ(0, root->child_count());
 }
 
 TEST_F(BookmarkModelTest, NonMovingMoveCall) {
   const BookmarkNode* root = model_.bookmark_bar_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
   const base::Time old_date(base::Time::Now() - base::TimeDelta::FromDays(1));
 
   const BookmarkNode* node = model_.AddURL(root, 0, title, url);
   model_.SetDateFolderModified(root, old_date);
 
   // Since |node| is already at the index 0 of |root|, this is no-op.
   model_.Move(node, root, 0);
 
   // Check that the modification date is kept untouched.
@@ skipping 52 matching lines @@
   actual_model_string = test::ModelStringFromNode(root);
   EXPECT_EQ("a 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] d 1:[ b d c ] "
             "d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h d ",
             actual_model_string);
 }
 
 // Tests that adding a URL to a folder updates the last modified time.
 TEST_F(BookmarkModelTest, ParentForNewNodes) {
   ASSERT_EQ(model_.bookmark_bar_node(), model_.GetParentForNewNodes());
 
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   model_.AddURL(model_.other_node(), 0, title, url);
   ASSERT_EQ(model_.other_node(), model_.GetParentForNewNodes());
 }
 
 // Tests that adding a URL to a folder updates the last modified time.
 TEST_F(BookmarkModelTest, ParentForNewMobileNodes) {
   ASSERT_EQ(model_.bookmark_bar_node(), model_.GetParentForNewNodes());
 
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   model_.AddURL(model_.mobile_node(), 0, title, url);
   ASSERT_EQ(model_.mobile_node(), model_.GetParentForNewNodes());
 }
 
 // Make sure recently modified stays in sync when adding a URL.
 TEST_F(BookmarkModelTest, MostRecentlyModifiedFolders) {
   // Add a folder.
   const BookmarkNode* folder = model_.AddFolder(model_.other_node(), 0,
@@ skipping 77 matching lines @@
   ASSERT_EQ(n1, model_.GetMostRecentlyAddedNodeForURL(url));
 
   // swap 1 and 2, then check again.
   SwapDateAdded(n1, n2);
   ASSERT_EQ(n2, model_.GetMostRecentlyAddedNodeForURL(url));
 }
 
 // Makes sure GetBookmarks removes duplicates.
 TEST_F(BookmarkModelTest, GetBookmarksWithDups) {
   const GURL url("http://foo.com/0");
-  const string16 title(ASCIIToUTF16("blah"));
+  const base::string16 title(ASCIIToUTF16("blah"));
   model_.AddURL(model_.bookmark_bar_node(), 0, title, url);
   model_.AddURL(model_.bookmark_bar_node(), 1, title, url);
 
   std::vector<BookmarkService::URLAndTitle> bookmarks;
   model_.GetBookmarks(&bookmarks);
   ASSERT_EQ(1U, bookmarks.size());
   EXPECT_EQ(url, bookmarks[0].url);
   EXPECT_EQ(title, bookmarks[0].title);
 
   model_.AddURL(model_.bookmark_bar_node(), 2, ASCIIToUTF16("Title2"), url);
@@ skipping 273 matching lines @@
   const BookmarkNode* parent = model_.bookmark_bar_node();
   PopulateBookmarkNode(&bbn, &model_, parent);
   EXPECT_TRUE(parent->GetChild(0)->IsVisible());
 
   // Bookmark bar should be visible now that it has a child.
   EXPECT_TRUE(model_.bookmark_bar_node()->IsVisible());
 }
 
 TEST_F(BookmarkModelTest, MobileNodeVisibileWithChildren) {
   const BookmarkNode* root = model_.mobile_node();
-  const string16 title(ASCIIToUTF16("foo"));
+  const base::string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
   model_.AddURL(root, 0, title, url);
   EXPECT_TRUE(model_.mobile_node()->IsVisible());
 }
 
 TEST_F(BookmarkModelTest, ExtensiveChangesObserver) {
   AssertExtensiveChangesObserverCount(0, 0);
   EXPECT_FALSE(model_.IsDoingExtensiveChanges());
   model_.BeginExtensiveChanges();
@@ skipping 47 matching lines @@
   EXPECT_TRUE(node.DeleteMetaInfo("key2.subkey2.leaf"));
   EXPECT_FALSE(node.DeleteMetaInfo("key3"));
   EXPECT_FALSE(node.GetMetaInfo("key1", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey1", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey2", &out_value));
   EXPECT_FALSE(node.GetMetaInfo("key2.subkey2.leaf", &out_value));
   EXPECT_FALSE(node.GetMetaInfoMap());
 }
 
 }  // namespace