Add utf_string_conversions to base 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 136 matching lines @@
     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) {
     syncer::WriteNode node(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
     std::string old_title = node.GetTitle();
     node.SetTitle(new_title);
     SetModified(id);
-    return UTF8ToWide(old_title);
+    return base::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) {
     syncer::ReadNode parent(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
     syncer::WriteNode node(trans_);
     EXPECT_EQ(BaseNode::INIT_OK, node.InitByIdLookup(id));
@@ skipping 192 matching lines @@
         EXPECT_EQ(BaseNode::INIT_OK,
                   predecessor_node.InitByIdLookup(last_child_id));
         predecessor = &predecessor_node;
       }
       syncer::WriteNode node(&trans);
       if (!node.InitBookmarkByCreation(root, predecessor))
         return false;
       node.SetIsFolder(true);
       node.GetMutableEntryForTest()->Put(
           syncer::syncable::UNIQUE_SERVER_TAG, permanent_tags[i]);
-      node.SetTitle(UTF8ToWide(permanent_tags[i]));
+      node.SetTitle(base::UTF8ToWide(permanent_tags[i]));
       node.SetExternalId(0);
       last_child_id = node.GetId();
     }
     return true;
   }
 
   void StartSync() {
     test_user_share_.Reload();
 
     ASSERT_TRUE(CreatePermanentBookmarkNodes());
@@ skipping 141 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 716 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 414 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));
 }
 
 // Output transaction versions of |node| and nodes under it to |node_versions|.
 void GetTransactionVersions(
     const BookmarkNode* root,
     BookmarkNodeVersionMap* node_versions) {
   node_versions->clear();
   std::queue<const BookmarkNode*> nodes;
@@ skipping 78 matching lines @@
                           kBookmarkTransactionVersionKey, "41");
   initial_versions[bookmark_bar->GetChild(0)->id()] = 41;
   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::WideToUTF16Hack(L"test"));
   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_EQ(initial_versions[changed_bookmark->id()] + 1,
             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);
 }
 
 }  // namespace
 
 }  // namespace browser_sync