Remove UTF string conversion functions from the global namespace.

chrome/browser/sync/profile_sync_service_bookmark_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.
 
 // TODO(akalin): This file is basically just a unit test for
 // BookmarkChangeProcessor.  Write unit tests for
 // BookmarkModelAssociator separately.
 
 #include <map>
 #include <queue>
@@ skipping 636 matching lines @@
 
   void ExpectSyncerNodeUnknown(const BookmarkNode* node) {
     int64 sync_id = model_associator_->GetSyncIdFromChromeId(node->id());
     EXPECT_EQ(sync_id, syncer::kInvalidId);
   }
 
   void ExpectBrowserNodeTitle(int64 sync_id, const std::wstring& title) {
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
-    EXPECT_EQ(bnode->GetTitle(), WideToUTF16Hack(title));
+    EXPECT_EQ(bnode->GetTitle(), base::WideToUTF16Hack(title));
   }
 
   void ExpectBrowserNodeURL(int64 sync_id, const std::string& url) {
     const BookmarkNode* bnode =
         model_associator_->GetChromeNodeFromSyncId(sync_id);
     ASSERT_TRUE(bnode);
     EXPECT_EQ(GURL(url), bnode->url());
   }
 
   void ExpectBrowserNodeParent(int64 sync_id, int64 parent_sync_id) {
@@ skipping 755 matching lines @@
     int size,
     int* running_count) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   for (int i = 0; i < size; ++i) {
     const TestData& item = data[i];
     if (item.url) {
       const base::Time add_time =
           start_time_ + base::TimeDelta::FromMinutes(*running_count);
-      model_->AddURLWithCreationTime(node, i, WideToUTF16Hack(item.title),
+      model_->AddURLWithCreationTime(node, i, base::WideToUTF16Hack(item.title),
                                      GURL(item.url), add_time);
     } else {
-      model_->AddFolder(node, i, WideToUTF16Hack(item.title));
+      model_->AddFolder(node, i, base::WideToUTF16Hack(item.title));
     }
     (*running_count)++;
   }
 }
 
 void ProfileSyncServiceBookmarkTestWithData::CompareWithTestData(
     const BookmarkNode* node,
     const TestData* data,
     int size,
     int* running_count) {
   DCHECK(node);
   DCHECK(data);
   DCHECK(node->is_folder());
   ASSERT_EQ(size, node->child_count());
   for (int i = 0; i < size; ++i) {
     const BookmarkNode* child_node = node->GetChild(i);
     const TestData& item = data[i];
     GURL url = GURL(item.url == NULL ? "" : item.url);
     BookmarkNode test_node(url);
-    test_node.SetTitle(WideToUTF16Hack(item.title));
+    test_node.SetTitle(base::WideToUTF16Hack(item.title));
     EXPECT_EQ(child_node->GetTitle(), test_node.GetTitle());
     if (item.url) {
       EXPECT_FALSE(child_node->is_folder());
       EXPECT_TRUE(child_node->is_url());
       EXPECT_EQ(child_node->url(), test_node.url());
       const base::Time expected_time =
           start_time_ + base::TimeDelta::FromMinutes(*running_count);
       EXPECT_EQ(expected_time.ToInternalValue(),
                 child_node->date_added().ToInternalValue());
     } else {
@@ skipping 421 matching lines @@
   int64 id = adds.AddURL(kTitle, kUrl,
                          bookmark_bar_id(), 0);
   adds.ApplyPendingChanges(change_processor_.get());
   FakeServerChange updates(&trans);
   updates.ModifyCreationTime(id, kCreationTime);
   updates.ApplyPendingChanges(change_processor_.get());
 
   const BookmarkNode* node = model_->bookmark_bar_node()->GetChild(0);
   ASSERT_TRUE(node);
   EXPECT_TRUE(node->is_url());
-  EXPECT_EQ(WideToUTF16Hack(kTitle), node->GetTitle());
+  EXPECT_EQ(base::WideToUTF16Hack(kTitle), node->GetTitle());
   EXPECT_EQ(kUrl, node->url().possibly_invalid_spec());
   EXPECT_EQ(node->date_added(), base::Time::FromInternalValue(30));
 }
 
 // Tests that changes to the sync nodes meta info gets reflected in the local
 // bookmark model.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, UpdateMetaInfoFromSync) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   WriteTestDataToBookmarkModel();
   StartSync();
@@ skipping 145 matching lines @@
   EXPECT_EQ(initial_versions[model_->root_node()->id()] + 1,
             new_versions[model_->root_node()->id()]);
   ExpectTransactionVersionMatch(model_->bookmark_bar_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->other_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->mobile_node(), initial_versions);
 
   // Verify model version and version of changed bookmark are incremented and
   // versions of others remain same.
   const BookmarkNode* changed_bookmark =
       model_->bookmark_bar_node()->GetChild(0);
-  model_->SetTitle(changed_bookmark, WideToUTF16Hack(L"test"));
+  model_->SetTitle(changed_bookmark, base::ASCIIToUTF16("test"));
   base::MessageLoop::current()->RunUntilIdle();
   GetTransactionVersions(model_->root_node(), &new_versions);
   EXPECT_EQ(initial_versions[model_->root_node()->id()] + 2,
             new_versions[model_->root_node()->id()]);
   EXPECT_LT(initial_versions[changed_bookmark->id()],
             new_versions[changed_bookmark->id()]);
   initial_versions.erase(changed_bookmark->id());
   ExpectTransactionVersionMatch(model_->bookmark_bar_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->other_node(), initial_versions);
   ExpectTransactionVersionMatch(model_->mobile_node(), initial_versions);
@@ skipping 31 matching lines @@
   int64 root_version = initial_versions[model_->root_node()->id()];
   model_->SetNodeSyncTransactionVersion(model_->root_node(), root_version + 1);
 
   // Upon association, bookmarks should fail to associate.
   EXPECT_FALSE(AssociateModels());
 }
 
 }  // namespace
 
 }  // namespace browser_sync