sync: Make BaseNode::GetTitle() return std::string.

chrome/browser/sync/profile_sync_service_bookmark_unittest.cc

 // Copyright (c) 2011 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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <stack>
 #include <vector>
@@ skipping 40 matching lines @@
       sync_api::UserShare* user_share,
       UnrecoverableErrorHandler* unrecoverable_error_handler)
       : BookmarkModelAssociator(bookmark_model, user_share,
                                 unrecoverable_error_handler),
         user_share_(user_share) {}
 
   // TODO(akalin): This logic lazily creates any tagged node that is
   // requested.  A better way would be to have utility functions to
   // create sync nodes from some bookmark structure and to use that.
   virtual bool GetSyncIdForTaggedNode(const std::string& tag, int64* sync_id) {
-    std::wstring tag_wide;
-    if (!UTF8ToWide(tag.c_str(), tag.length(), &tag_wide)) {
-      NOTREACHED() << "Unable to convert UTF8 to wide for string: " << tag;
-      return false;
-    }
-
+    std::string tag_str = std::string(tag.c_str(), tag.length());
     bool root_exists = false;
     syncable::ModelType type = model_type();
     {
       sync_api::WriteTransaction trans(FROM_HERE, user_share_);
       sync_api::ReadNode uber_root(&trans);
       uber_root.InitByRootLookup();
 
       sync_api::ReadNode root(&trans);
       root_exists = root.InitByTagLookup(
           ProfileSyncServiceTestHelper::GetTagForType(type));
@@ skipping 14 matching lines @@
         ProfileSyncServiceTestHelper::GetTagForType(type)));
 
     // First, try to find a node with the title among the root's children.
     // This will be the case if we are testing model persistence, and
     // are reloading a sync repository created earlier in the test.
     int64 last_child_id = sync_api::kInvalidId;
     for (int64 id = root.GetFirstChildId(); id != sync_api::kInvalidId; /***/) {
       sync_api::ReadNode child(&trans);
       child.InitByIdLookup(id);
       last_child_id = id;
-      if (tag_wide == child.GetTitle()) {
+      if (tag_str == child.GetTitle()) {
         *sync_id = id;
         return true;
       }
       id = child.GetSuccessorId();
     }
 
     sync_api::ReadNode predecessor_node(&trans);
     sync_api::ReadNode* predecessor = NULL;
     if (last_child_id != sync_api::kInvalidId) {
       predecessor_node.InitByIdLookup(last_child_id);
       predecessor = &predecessor_node;
     }
     sync_api::WriteNode node(&trans);
     // Create new fake tagged nodes at the end of the ordering.
     node.InitByCreation(type, root, predecessor);
     node.SetIsFolder(true);
-    node.SetTitle(tag_wide);
+    node.SetTitle(UTF8ToWide(tag_str));
     node.SetExternalId(0);
     *sync_id = node.GetId();
     return true;
   }
 
  private:
   sync_api::UserShare* user_share_;
   browser_sync::TestIdFactory id_factory_;
 };
 
@@ skipping 77 matching lines @@
     // a practical matter, users of FakeServerChange must move or delete
     // children before parents.  Thus, we must insert the deletion record
     // at the front of the vector.
     changes_.insert(changes_.begin(), record);
   }
 
   // Set a new title value, and return the old value.
   std::wstring ModifyTitle(int64 id, const std::wstring& new_title) {
     sync_api::WriteNode node(trans_);
     EXPECT_TRUE(node.InitByIdLookup(id));
-    std::wstring old_title = node.GetTitle();
+    std::string old_title = node.GetTitle();
     node.SetTitle(new_title);
     SetModified(id);
-    return old_title;
+    return UTF8ToWide(old_title);
   }
 
   // Set a new parent and predecessor value.  Return the old parent id.
   // We could return the old predecessor id, but it turns out not to be
   // very useful for assertions.
   int64 ModifyPosition(int64 id, int64 parent_id, int64 predecessor_id) {
     sync_api::ReadNode parent(trans_);
     EXPECT_TRUE(parent.InitByIdLookup(parent_id));
     sync_api::WriteNode node(trans_);
     EXPECT_TRUE(node.InitByIdLookup(id));
@@ skipping 133 matching lines @@
     return model_associator_->InitSyncNodeFromChromeId(bnode->id(),
                                                        sync_node);
   }
 
   void ExpectSyncerNodeMatching(sync_api::BaseTransaction* trans,
                                 const BookmarkNode* bnode) {
     sync_api::ReadNode gnode(trans);
     ASSERT_TRUE(InitSyncNodeFromChromeNode(bnode, &gnode));
     // Non-root node titles and parents must match.
     if (!model_->is_permanent_node(bnode)) {
-      EXPECT_EQ(bnode->GetTitle(), WideToUTF16Hack(gnode.GetTitle()));
+      EXPECT_EQ(bnode->GetTitle(), UTF8ToUTF16(gnode.GetTitle()));
       EXPECT_EQ(
           model_associator_->GetChromeNodeFromSyncId(gnode.GetParentId()),
           bnode->parent());
     }
     EXPECT_EQ(bnode->is_folder(), gnode.GetIsFolder());
     if (bnode->is_url())
       EXPECT_EQ(bnode->url(), gnode.GetURL());
 
     // Check for position matches.
     int browser_index = bnode->parent()->GetIndexOf(bnode);
@@ skipping 1048 matching lines @@
   // Make sure we're back in sync.  In real life, the user would need
   // to reauthenticate before this happens, but in the test, authentication
   // is sidestepped.
   ExpectBookmarkModelMatchesTestData();
   ExpectModelMatch();
 }
 
 }  // namespace
 
 }  // namespace browser_sync