Remove wstrings from bookmarks, part 13.

chrome/browser/bookmarks/bookmark_model_unittest.cc

 // Copyright (c) 2010 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 <set>
 
 #include "app/tree_node_iterator.h"
 #include "app/tree_node_model.h"
 #include "base/base_paths.h"
 #include "base/file_util.h"
@@ skipping 297 matching lines @@
   ClearCounts();
   model.Remove(root, 0);
   AssertObserverCount(0, 0, 1, 0, 0);
   observer_details.AssertEquals(root, NULL, 0, -1);
   EXPECT_TRUE(model.GetMostRecentlyAddedNodeForURL(url) == NULL);
   EXPECT_EQ(0, root->GetChildCount());
 }
 
 TEST_F(BookmarkModelTest, Copy) {
   const BookmarkNode* root = model.GetBookmarkBarNode();
-  static const std::wstring model_string(L"a 1:[ b c ] d 2:[ e f g ] h ");
+  static const std::string model_string("a 1:[ b c ] d 2:[ e f g ] h ");
   model_test_utils::AddNodesFromModelString(model, root, model_string);
 
   // Validate initial model.
-  std::wstring actualModelString = model_test_utils::ModelStringFromNode(root);
+  std::string actualModelString = model_test_utils::ModelStringFromNode(root);
   EXPECT_EQ(model_string, actualModelString);
 
   // Copy 'd' to be after '1:b': URL item from bar to folder.
   const BookmarkNode* nodeToCopy = root->GetChild(2);
   const BookmarkNode* destination = root->GetChild(1);
   model.Copy(nodeToCopy, destination, 1);
   actualModelString = model_test_utils::ModelStringFromNode(root);
-  EXPECT_EQ(L"a 1:[ b d c ] d 2:[ e f g ] h ", actualModelString);
+  EXPECT_EQ("a 1:[ b d c ] d 2:[ e f g ] h ", actualModelString);
 
   // Copy '1:d' to be after 'a': URL item from folder to bar.
   const BookmarkNode* group = root->GetChild(1);
   nodeToCopy = group->GetChild(1);
   model.Copy(nodeToCopy, root, 1);
   actualModelString = model_test_utils::ModelStringFromNode(root);
-  EXPECT_EQ(L"a d 1:[ b d c ] d 2:[ e f g ] h ", actualModelString);
+  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e f g ] h ", actualModelString);
 
   // Copy '1' to be after '2:e': Folder from bar to folder.
   nodeToCopy = root->GetChild(2);
   destination = root->GetChild(4);
   model.Copy(nodeToCopy, destination, 1);
   actualModelString = model_test_utils::ModelStringFromNode(root);
-  EXPECT_EQ(L"a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f g ] h ", actualModelString);
+  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f g ] h ", actualModelString);
 
   // Copy '2:1' to be after '2:f': Folder within same folder.
   group = root->GetChild(4);
   nodeToCopy = group->GetChild(1);
   model.Copy(nodeToCopy, group, 3);
   actualModelString = model_test_utils::ModelStringFromNode(root);
-  EXPECT_EQ(L"a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h ",
+  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h ",
             actualModelString);
 
   // Copy first 'd' to be after 'h': URL item within the bar.
   nodeToCopy = root->GetChild(1);
   model.Copy(nodeToCopy, root, 6);
   actualModelString = model_test_utils::ModelStringFromNode(root);
-  EXPECT_EQ(L"a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h d ",
+  EXPECT_EQ("a d 1:[ b d c ] d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h d ",
             actualModelString);
 
   // Copy '2' to be after 'a': Folder within the bar.
   nodeToCopy = root->GetChild(4);
   model.Copy(nodeToCopy, root, 1);
   actualModelString = model_test_utils::ModelStringFromNode(root);
-  EXPECT_EQ(L"a 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] d 1:[ b d c ] "
-            L"d 2:[ e 1:[ b d c ] f 1:[ b d c ] g ] h d ",
+  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 ",
             actualModelString);
 }
 
 // Tests that adding a URL to a folder updates the last modified time.
 TEST_F(BookmarkModelTest, ParentForNewNodes) {
   ASSERT_EQ(model.GetBookmarkBarNode(), model.GetParentForNewNodes());
 
   const string16 title(ASCIIToUTF16("foo"));
   const GURL url("http://foo.com");
 
@@ skipping 176 matching lines @@
   EXPECT_TRUE(url == *(listener.details_.changed_urls.begin()));
 }
 
 namespace {
 
 // See comment in PopulateNodeFromString.
 typedef TreeNodeWithValue<BookmarkNode::Type> TestNode;
 
 // Does the work of PopulateNodeFromString. index gives the index of the current
 // element in description to process.
-static void PopulateNodeImpl(const std::vector<std::wstring>& description,
+static void PopulateNodeImpl(const std::vector<std::string>& description,
                              size_t* index,
                              TestNode* parent) {
   while (*index < description.size()) {
-    const std::wstring& element = description[*index];
+    const std::string& element = description[*index];
     (*index)++;
-    if (element == L"[") {
+    if (element == "[") {
       // Create a new group and recurse to add all the children.
       // Groups are given a unique named by way of an ever increasing integer
       // value. The groups need not have a name, but one is assigned to help
       // in debugging.
       static int next_group_id = 1;
       TestNode* new_node =
-          new TestNode(UTF8ToWide(base::IntToString(next_group_id++)),
+          new TestNode(UTF16ToWideHack(base::IntToString16(next_group_id++)),
                        BookmarkNode::FOLDER);
       parent->Add(parent->GetChildCount(), new_node);
       PopulateNodeImpl(description, index, new_node);
-    } else if (element == L"]") {
+    } else if (element == "]") {
       // End the current group.
       return;
     } else {
       // Add a new URL.
 
       // All tokens must be space separated. If there is a [ or ] in the name it
       // likely means a space was forgotten.
       DCHECK(element.find('[') == std::string::npos);
       DCHECK(element.find(']') == std::string::npos);
       parent->Add(parent->GetChildCount(),
-                  new TestNode(element, BookmarkNode::URL));
+                  new TestNode(UTF8ToWide(element), BookmarkNode::URL));
     }
   }
 }
 
 // Creates and adds nodes to parent based on description. description consists
 // of the following tokens (all space separated):
 //   [ : creates a new USER_GROUP node. All elements following the [ until the
 //       next balanced ] is encountered are added as children to the node.
 //   ] : closes the last group created by [ so that any further nodes are added
 //       to the current groups parent.
 //   text: creates a new URL node.
 // For example, "a [b] c" creates the following nodes:
 //   a 1 c
 //     |
 //     b
 // In words: a node of type URL with the title a, followed by a group node with
 // the title 1 having the single child of type url with name b, followed by
 // the url node with the title c.
 //
 // NOTE: each name must be unique, and groups are assigned a unique title by way
 // of an increasing integer.
-static void PopulateNodeFromString(const std::wstring& description,
+static void PopulateNodeFromString(const std::string& description,
                                    TestNode* parent) {
-  std::vector<std::wstring> elements;
+  std::vector<std::string> elements;
   size_t index = 0;
   SplitStringAlongWhitespace(description, &elements);
   PopulateNodeImpl(elements, &index, parent);
 }
 
 // Populates the BookmarkNode with the children of parent.
 static void PopulateBookmarkNode(TestNode* parent,
                                  BookmarkModel* model,
                                  const BookmarkNode* bb_node) {
   for (int i = 0; i < parent->GetChildCount(); ++i) {
@@ skipping 113 matching lines @@
   ChromeThread ui_thread_;
   ChromeThread file_thread_;
 };
 
 // Creates a set of nodes in the bookmark bar model, then recreates the
 // bookmark bar model which triggers loading from the db and checks the loaded
 // structure to make sure it is what we first created.
 TEST_F(BookmarkModelTestWithProfile, CreateAndRestore) {
   struct TestData {
     // Structure of the children of the bookmark bar model node.
-    const std::wstring bbn_contents;
+    const std::string bbn_contents;
     // Structure of the children of the other node.
-    const std::wstring other_contents;
+    const std::string other_contents;
   } data[] = {
     // See PopulateNodeFromString for a description of these strings.
-    { L"", L"" },
-    { L"a", L"b" },
-    { L"a [ b ]", L"" },
-    { L"", L"[ b ] a [ c [ d e [ f ] ] ]" },
-    { L"a [ b ]", L"" },
-    { L"a b c [ d e [ f ] ]", L"g h i [ j k [ l ] ]"},
+    { "", "" },
+    { "a", "b" },
+    { "a [ b ]", "" },
+    { "", "[ b ] a [ c [ d e [ f ] ] ]" },
+    { "a [ b ]", "" },
+    { "a b c [ d e [ f ] ]", "g h i [ j k [ l ] ]"},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     // Recreate the profile. We need to reset with NULL first so that the last
     // HistoryService releases the locks on the files it creates and we can
     // delete them.
     profile_.reset(NULL);
     profile_.reset(new TestingProfile());
     profile_->CreateBookmarkModel(true);
     profile_->CreateHistoryService(true, false);
     BlockTillBookmarkModelLoaded();
@@ skipping 182 matching lines @@
 
   // This won't actually delete the URL, rather it'll empty out the visits.
   // This triggers blocking on the BookmarkModel.
   profile_->GetHistoryService(Profile::EXPLICIT_ACCESS)->DeleteURL(url);
 }
 
 TEST_F(BookmarkModelTest, Sort) {
   // Populate the bookmark bar node with nodes for 'B', 'a', 'd' and 'C'.
   // 'C' and 'a' are folders.
   TestNode bbn;
-  PopulateNodeFromString(L"B [ a ] d [ a ]", &bbn);
+  PopulateNodeFromString("B [ a ] d [ a ]", &bbn);
   const BookmarkNode* parent = model.GetBookmarkBarNode();
   PopulateBookmarkNode(&bbn, &model, parent);
 
   BookmarkNode* child1 = AsMutable(parent->GetChild(1));
   child1->SetTitle(ASCIIToUTF16("a"));
   delete child1->Remove(0);
   BookmarkNode* child3 = AsMutable(parent->GetChild(3));
   child3->SetTitle(ASCIIToUTF16("C"));
   delete child3->Remove(0);
 
   ClearCounts();
 
   // Sort the children of the bookmark bar node.
   model.SortChildren(parent);
 
   // Make sure we were notified.
   AssertObserverCount(0, 0, 0, 0, 1);
 
   // Make sure the order matches (remember, 'a' and 'C' are folders and
   // come first).
   EXPECT_EQ(parent->GetChild(0)->GetTitleAsString16(), ASCIIToUTF16("a"));
   EXPECT_EQ(parent->GetChild(1)->GetTitleAsString16(), ASCIIToUTF16("C"));
   EXPECT_EQ(parent->GetChild(2)->GetTitleAsString16(), ASCIIToUTF16("B"));
   EXPECT_EQ(parent->GetChild(3)->GetTitleAsString16(), ASCIIToUTF16("d"));
 }