Update some uses of UTF conversions in chrome/browser to use the 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 165 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 150 matching lines @@
   int64 AddFolderToShare(syncer::WriteTransaction* trans, std::string title) {
     EXPECT_FALSE(model_associator_);
 
     // Be sure to call CreatePermanentBookmarkNodes(), otherwise this will fail.
     syncer::ReadNode bookmark_bar(trans);
     EXPECT_EQ(BaseNode::INIT_OK, bookmark_bar.InitByTagLookup("bookmark_bar"));
 
     syncer::WriteNode node(trans);
     EXPECT_TRUE(node.InitBookmarkByCreation(bookmark_bar, NULL));
     node.SetIsFolder(true);
-    node.SetTitle(ASCIIToWide(title));
+    node.SetTitle(base::ASCIIToWide(title));
 
     return node.GetId();
   }
 
   // Inserts a bookmark directly to the share.
   // Do not use this after model association is complete.
   //
   // This function differs from the AddURL() function declared elsewhere in this
   // file in that it only affects the sync model.  It would be invalid to change
   // the sync model directly after ModelAssociation.  This function can be
   // invoked prior to model association to set up first-time sync model
   // association scenarios.
   int64 AddBookmarkToShare(syncer::WriteTransaction *trans,
                            int64 parent_id,
                            std::string title) {
     EXPECT_FALSE(model_associator_);
 
     syncer::ReadNode parent(trans);
     EXPECT_EQ(BaseNode::INIT_OK, parent.InitByIdLookup(parent_id));
 
     sync_pb::BookmarkSpecifics specifics;
     specifics.set_url("http://www.google.com/search?q=" + title);
     specifics.set_title(title);
 
     syncer::WriteNode node(trans);
     EXPECT_TRUE(node.InitBookmarkByCreation(parent, NULL));
     node.SetIsFolder(false);
-    node.SetTitle(ASCIIToWide(title));
+    node.SetTitle(base::ASCIIToWide(title));
     node.SetBookmarkSpecifics(specifics);
 
     return node.GetId();
   }
 
   // Load (or re-load) the bookmark model.  |load| controls use of the
   // bookmarks file on disk.  |save| controls whether the newly loaded
   // bookmark model will write out a bookmark file as it goes.
   void LoadBookmarkModel(LoadOption load, SaveOption save) {
     bool delete_bookmarks = load == DELETE_EXISTING_STORAGE;
@@ skipping 65 matching lines @@
       if (last_child_id != syncer::kInvalidId) {
         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()->PutUniqueServerTag(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;
   }
 
   bool AssociateModels() {
     DCHECK(!model_associator_);
 
     // Set up model associator.
@@ skipping 76 matching lines @@
     return model_associator_->InitSyncNodeFromChromeId(bnode->id(),
                                                        sync_node);
   }
 
   void ExpectSyncerNodeMatching(syncer::BaseTransaction* trans,
                                 const BookmarkNode* bnode) {
     syncer::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(), UTF8ToUTF16(gnode.GetTitle()));
+      EXPECT_EQ(bnode->GetTitle(), base::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(), GURL(gnode.GetBookmarkSpecifics().url()));
 
     // Check that meta info matches.
     const BookmarkNode::MetaInfoMap* meta_info_map = bnode->GetMetaInfoMap();
@@ skipping 203 matching lines @@
   ExpectModelMatch();
 }
 
 
 TEST_F(ProfileSyncServiceBookmarkTest, BookmarkModelOperations) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   // Test addition.
   const BookmarkNode* folder =
-      model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16("foobar"));
+      model_->AddFolder(model_->other_node(), 0, base::ASCIIToUTF16("foobar"));
   ExpectSyncerNodeMatching(folder);
   ExpectModelMatch();
   const BookmarkNode* folder2 =
-      model_->AddFolder(folder, 0, ASCIIToUTF16("nested"));
+      model_->AddFolder(folder, 0, base::ASCIIToUTF16("nested"));
   ExpectSyncerNodeMatching(folder2);
   ExpectModelMatch();
   const BookmarkNode* url1 = model_->AddURL(
-      folder, 0, ASCIIToUTF16("Internets #1 Pies Site"),
+      folder, 0, base::ASCIIToUTF16("Internets #1 Pies Site"),
       GURL("http://www.easypie.com/"));
   ExpectSyncerNodeMatching(url1);
   ExpectModelMatch();
   const BookmarkNode* url2 = model_->AddURL(
-      folder, 1, ASCIIToUTF16("Airplanes"), GURL("http://www.easyjet.com/"));
+      folder, 1, base::ASCIIToUTF16("Airplanes"),
+      GURL("http://www.easyjet.com/"));
   ExpectSyncerNodeMatching(url2);
   ExpectModelMatch();
   // Test addition.
   const BookmarkNode* mobile_folder =
-      model_->AddFolder(model_->mobile_node(), 0, ASCIIToUTF16("pie"));
+      model_->AddFolder(model_->mobile_node(), 0, base::ASCIIToUTF16("pie"));
   ExpectSyncerNodeMatching(mobile_folder);
   ExpectModelMatch();
 
   // Test modification.
-  model_->SetTitle(url2, ASCIIToUTF16("EasyJet"));
+  model_->SetTitle(url2, base::ASCIIToUTF16("EasyJet"));
   ExpectModelMatch();
   model_->Move(url1, folder2, 0);
   ExpectModelMatch();
   model_->Move(folder2, model_->bookmark_bar_node(), 0);
   ExpectModelMatch();
-  model_->SetTitle(folder2, ASCIIToUTF16("Not Nested"));
+  model_->SetTitle(folder2, base::ASCIIToUTF16("Not Nested"));
   ExpectModelMatch();
   model_->Move(folder, folder2, 0);
   ExpectModelMatch();
-  model_->SetTitle(folder, ASCIIToUTF16("who's nested now?"));
+  model_->SetTitle(folder, base::ASCIIToUTF16("who's nested now?"));
   ExpectModelMatch();
   model_->Copy(url2, model_->bookmark_bar_node(), 0);
   ExpectModelMatch();
-  model_->SetTitle(mobile_folder, ASCIIToUTF16("strawberry"));
+  model_->SetTitle(mobile_folder, base::ASCIIToUTF16("strawberry"));
   ExpectModelMatch();
 
   // Test deletion.
   // Delete a single item.
   model_->Remove(url2->parent(), url2->parent()->GetIndexOf(url2));
   ExpectModelMatch();
   // Delete an item with several children.
   model_->Remove(folder2->parent(),
                  folder2->parent()->GetIndexOf(folder2));
   ExpectModelMatch();
@@ skipping 229 matching lines @@
       // Files created automatically by the Windows shell.
       "Thumbs.db", ".DS_Store",
       // Names including Win32-illegal characters, and path separators.
       "foo/bar", "foo\\bar", "foo?bar", "foo:bar", "foo|bar", "foo\"bar",
       "foo'bar", "foo<bar", "foo>bar", "foo%bar", "foo*bar", "foo]bar",
       "foo[bar",
   };
   // Create both folders and bookmarks using each name.
   GURL url("http://www.doublemint.com");
   for (size_t i = 0; i < arraysize(names); ++i) {
-    model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16(names[i]));
-    model_->AddURL(model_->other_node(), 0, ASCIIToUTF16(names[i]), url);
+    model_->AddFolder(model_->other_node(), 0, base::ASCIIToUTF16(names[i]));
+    model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16(names[i]), url);
   }
 
   // Verify that the browser model matches the sync model.
   EXPECT_TRUE(model_->other_node()->child_count() == 2*arraysize(names));
   ExpectModelMatch();
 }
 
 // Stress the internal representation of position by sparse numbers. We want
 // to repeatedly bisect the range of available positions, to force the
 // syncer code to renumber its ranges.  Pick a number big enough so that it
 // would exhaust 32bits of room between items a couple of times.
 TEST_F(ProfileSyncServiceBookmarkTest, RepeatedMiddleInsertion) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   static const int kTimesToInsert = 256;
 
   // Create two book-end nodes to insert between.
-  model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16("Alpha"));
-  model_->AddFolder(model_->other_node(), 1, ASCIIToUTF16("Omega"));
+  model_->AddFolder(model_->other_node(), 0, base::ASCIIToUTF16("Alpha"));
+  model_->AddFolder(model_->other_node(), 1, base::ASCIIToUTF16("Omega"));
   int count = 2;
 
   // Test insertion in first half of range by repeatedly inserting in second
   // position.
   for (int i = 0; i < kTimesToInsert; ++i) {
     base::string16 title =
-        ASCIIToUTF16("Pre-insertion ") + base::IntToString16(i);
+        base::ASCIIToUTF16("Pre-insertion ") + base::IntToString16(i);
     model_->AddFolder(model_->other_node(), 1, title);
     count++;
   }
 
   // Test insertion in second half of range by repeatedly inserting in
   // second-to-last position.
   for (int i = 0; i < kTimesToInsert; ++i) {
     base::string16 title =
-        ASCIIToUTF16("Post-insertion ") + base::IntToString16(i);
+        base::ASCIIToUTF16("Post-insertion ") + base::IntToString16(i);
     model_->AddFolder(model_->other_node(), count - 1, title);
     count++;
   }
 
   // Verify that the browser model matches the sync model.
   EXPECT_EQ(model_->other_node()->child_count(), count);
   ExpectModelMatch();
 }
 
 // Introduce a consistency violation into the model, and see that it
 // puts itself into a lame, error state.
 TEST_F(ProfileSyncServiceBookmarkTest, UnrecoverableErrorSuspendsService) {
   EXPECT_CALL(mock_error_handler_,
               OnSingleDatatypeUnrecoverableError(_, _));
 
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   StartSync();
 
   // Add a node which will be the target of the consistency violation.
   const BookmarkNode* node =
-      model_->AddFolder(model_->other_node(), 0, ASCIIToUTF16("node"));
+      model_->AddFolder(model_->other_node(), 0, base::ASCIIToUTF16("node"));
   ExpectSyncerNodeMatching(node);
 
   // Now destroy the syncer node as if we were the ProfileSyncService without
   // updating the ProfileSyncService state.  This should introduce
   // inconsistency between the two models.
   {
     syncer::WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     syncer::WriteNode sync_node(&trans);
     ASSERT_TRUE(InitSyncNodeFromChromeNode(node, &sync_node));
     sync_node.Tombstone();
   }
   // The models don't match at this point, but the ProfileSyncService
   // doesn't know it yet.
   ExpectSyncerNodeKnown(node);
 
   // Add a child to the inconsistent node.  This should cause detection of the
   // problem and the syncer should stop processing changes.
-  model_->AddFolder(node, 0, ASCIIToUTF16("nested"));
+  model_->AddFolder(node, 0, base::ASCIIToUTF16("nested"));
 }
 
 // See what happens if we run model association when there are two exact URL
 // duplicate bookmarks.  The BookmarkModelAssociator should not fall over when
 // this happens.
 TEST_F(ProfileSyncServiceBookmarkTest, MergeDuplicates) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, SAVE_TO_STORAGE);
   StartSync();
 
-  model_->AddURL(model_->other_node(), 0, ASCIIToUTF16("Dup"),
+  model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("Dup"),
                  GURL("http://dup.com/"));
-  model_->AddURL(model_->other_node(), 0, ASCIIToUTF16("Dup"),
+  model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("Dup"),
                  GURL("http://dup.com/"));
 
   EXPECT_EQ(2, model_->other_node()->child_count());
 
   // Restart the sync service to trigger model association.
   StopSync();
   StartSync();
 
   EXPECT_EQ(2, model_->other_node()->child_count());
   ExpectModelMatch();
@@ skipping 45 matching lines @@
   StopSync();
   // Bookmark bar itself and u0 remain.
   EXPECT_EQ(2, model_->bookmark_bar_node()->GetTotalNodeCount());
 
   // Reload bookmarks including ones deleted in sync model from storage.
   LoadBookmarkModel(LOAD_FROM_STORAGE, DONT_SAVE_TO_STORAGE);
   EXPECT_EQ(6, model_->bookmark_bar_node()->GetTotalNodeCount());
   // Add a bookmark under f1 when sync is off so that f1 will not be
   // deleted even when f1 matches delete journal because it's not empty.
   model_->AddURL(model_->bookmark_bar_node()->GetChild(1),
-                 0, UTF8ToUTF16("local"), GURL("http://www.youtube.com"));
+                 0, base::UTF8ToUTF16("local"), GURL("http://www.youtube.com"));
   // Sync model has fixed bookmarks nodes and u3.
   EXPECT_EQ(fixed_sync_bk_count + 1, GetSyncBookmarkCount());
   StartSync();
   // Expect 4 bookmarks after model association because u2, f2, u1 are removed
   // by delete journal, f1 is not removed by delete journal because it's
   // not empty due to www.youtube.com added above.
   EXPECT_EQ(4, model_->bookmark_bar_node()->GetTotalNodeCount());
-  EXPECT_EQ(UTF8ToUTF16("URL 0"),
+  EXPECT_EQ(base::UTF8ToUTF16("URL 0"),
             model_->bookmark_bar_node()->GetChild(0)->GetTitle());
-  EXPECT_EQ(UTF8ToUTF16("Folder 1"),
+  EXPECT_EQ(base::UTF8ToUTF16("Folder 1"),
             model_->bookmark_bar_node()->GetChild(1)->GetTitle());
-  EXPECT_EQ(UTF8ToUTF16("local"),
+  EXPECT_EQ(base::UTF8ToUTF16("local"),
             model_->bookmark_bar_node()->GetChild(1)->GetChild(0)->GetTitle());
   StopSync();
 
   // Verify purging of delete journals.
   // Delete journals for u2, f2, u1 remains because they are used in last
   // association.
   EXPECT_EQ(3u, test_user_share_.GetDeleteJournalSize());
   StartSync();
   StopSync();
   // Reload again and all delete journals should be gone because none is used
@@ skipping 513 matching lines @@
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   WriteTestDataToBookmarkModel();
   StartSync();
   ExpectModelMatch();
   // Force sync to shut down and write itself to disk.
   StopSync();
   // Change the bookmark model before restarting sync service to simulate
   // the situation where bookmark model is different from sync model and
   // make sure model associator correctly rebuilds associations.
   const BookmarkNode* bookmark_bar_node = model_->bookmark_bar_node();
-  model_->AddURL(bookmark_bar_node, 0, ASCIIToUTF16("xtra"),
+  model_->AddURL(bookmark_bar_node, 0, base::ASCIIToUTF16("xtra"),
                  GURL("http://www.xtra.com"));
   // Now restart sync. This time it will try to use the persistent
   // associations and realize that they are invalid and hence will rebuild
   // associations.
   StartSync();
   ExpectModelMatch();
 }
 
 TEST_F(ProfileSyncServiceBookmarkTestWithData, SortChildren) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
@@ skipping 159 matching lines @@
 // Tests that changes to the local bookmark nodes meta info gets reflected in
 // the sync nodes.
 TEST_F(ProfileSyncServiceBookmarkTestWithData, UpdateMetaInfoFromModel) {
   LoadBookmarkModel(DELETE_EXISTING_STORAGE, DONT_SAVE_TO_STORAGE);
   WriteTestDataToBookmarkModel();
   StartSync();
   ExpectBookmarkModelMatchesTestData();
 
   const BookmarkNode* folder_node =
       model_->AddFolder(model_->bookmark_bar_node(), 0,
-                        ASCIIToUTF16("folder title"));
+                        base::ASCIIToUTF16("folder title"));
   const BookmarkNode* node = model_->AddURL(folder_node, 0,
-                                            ASCIIToUTF16("node title"),
+                                            base::ASCIIToUTF16("node title"),
                                             GURL("http://www.foo.com"));
   ExpectModelMatch();
 
   // Add some meta info and verify sync model matches the changes.
   model_->SetNodeMetaInfo(folder_node, "folder", "foldervalue");
   model_->SetNodeMetaInfo(node, "node", "nodevalue");
   model_->SetNodeMetaInfo(node, "other", "othervalue");
   ExpectModelMatch();
 
   // Change/delete existing meta info and verify.
@@ skipping 133 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