Update uses of UTF conversions in ppapi/, printing/, remoting/, rlz/, sandbox/, skia/, sql/, sync/,…

sync/internal_api/sync_manager_impl_unittest.cc

 // Copyright 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.
 
 // Unit tests for the SyncApi. Note that a lot of the underlying
 // functionality is provided by the Syncable layer, which has its own
 // unit tests. We'll test SyncApi specific things in this harness.
 
 #include <cstddef>
 #include <map>
@@ skipping 335 matching lines @@
     // we'll use this spare folder later
     WriteNode folder_node(&trans);
     EXPECT_TRUE(folder_node.InitBookmarkByCreation(root_node, NULL));
     folder_id = folder_node.GetId();
 
     WriteNode wnode(&trans);
     WriteNode::InitUniqueByCreationResult result =
         wnode.InitUniqueByCreation(BOOKMARKS, root_node, "testtag");
     EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     wnode.SetIsFolder(false);
-    wnode.SetTitle(UTF8ToWide(test_title));
+    wnode.SetTitle(base::UTF8ToWide(test_title));
 
     node_id = wnode.GetId();
   }
 
   // Ensure we can delete something with a tag.
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     WriteNode wnode(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               wnode.InitByClientTagLookup(BOOKMARKS,
@@ skipping 24 matching lines @@
 
     WriteNode wnode(&trans);
     // This will undelete the tag.
     WriteNode::InitUniqueByCreationResult result =
         wnode.InitUniqueByCreation(BOOKMARKS, folder_node, "testtag");
     EXPECT_EQ(WriteNode::INIT_SUCCESS, result);
     EXPECT_EQ(wnode.GetIsFolder(), false);
     EXPECT_EQ(wnode.GetParentId(), folder_node.GetId());
     EXPECT_EQ(wnode.GetId(), node_id);
     EXPECT_NE(wnode.GetTitle(), test_title);  // Title should be cleared
-    wnode.SetTitle(UTF8ToWide(test_title));
+    wnode.SetTitle(base::UTF8ToWide(test_title));
   }
 
   // Now look up should work.
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS,
                     "testtag"));
     EXPECT_EQ(node.GetTitle(), test_title);
@@ skipping 44 matching lines @@
   test_user_share_.encryption_handler()->EnableEncryptEverything();
   int bookmark_id;
   {
     WriteTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     WriteNode bookmark_node(&trans);
     ASSERT_TRUE(bookmark_node.InitBookmarkByCreation(root_node, NULL));
     bookmark_id = bookmark_node.GetId();
-    bookmark_node.SetTitle(UTF8ToWide("foo"));
+    bookmark_node.SetTitle(base::UTF8ToWide("foo"));
 
     WriteNode pref_node(&trans);
     WriteNode::InitUniqueByCreationResult result =
         pref_node.InitUniqueByCreation(PREFERENCES, root_node, "bar");
     ASSERT_EQ(WriteNode::INIT_SUCCESS, result);
-    pref_node.SetTitle(UTF8ToWide("bar"));
+    pref_node.SetTitle(base::UTF8ToWide("bar"));
   }
   {
     ReadTransaction trans(FROM_HERE, test_user_share_.user_share());
     ReadNode root_node(&trans);
     root_node.InitByRootLookup();
 
     ReadNode bookmark_node(&trans);
     ASSERT_EQ(BaseNode::INIT_OK, bookmark_node.InitByIdLookup(bookmark_id));
     EXPECT_EQ("foo", bookmark_node.GetTitle());
     EXPECT_EQ(kEncryptedString,
@@ skipping 1633 matching lines @@
   std::string title = "title";
   std::string url = "url";
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode bookmark_root(&trans);
     ASSERT_EQ(BaseNode::INIT_OK,
               bookmark_root.InitByTagLookup(ModelTypeToRootTag(BOOKMARKS)));
     WriteNode node(&trans);
     ASSERT_TRUE(node.InitBookmarkByCreation(bookmark_root, NULL));
     node.SetIsFolder(false);
-    node.SetTitle(UTF8ToWide(title));
+    node.SetTitle(base::UTF8ToWide(title));
 
     sync_pb::BookmarkSpecifics bookmark_specifics(node.GetBookmarkSpecifics());
     bookmark_specifics.set_url(url);
     node.SetBookmarkSpecifics(bookmark_specifics);
   }
   {
     ReadTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     ReadNode bookmark_root(&trans);
     ASSERT_EQ(BaseNode::INIT_OK,
               bookmark_root.InitByTagLookup(ModelTypeToRootTag(BOOKMARKS)));
@@ skipping 318 matching lines @@
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
-    node.SetTitle(UTF8ToWide(client_tag));
+    node.SetTitle(base::UTF8ToWide(client_tag));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
-    node.SetTitle(UTF8ToWide("title2"));
+    node.SetTitle(base::UTF8ToWide("title2"));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // bookmarks when we write the same data, but does set it when we write new
 // data.
 TEST_F(SyncManagerTest, SetBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
@@ skipping 18 matching lines @@
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
-    node.SetTitle(UTF8ToWide(client_tag));
+    node.SetTitle(base::UTF8ToWide(client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
   }
   EXPECT_FALSE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 
   // Manually change to new title. Should set is_unsynced. NON_UNIQUE_NAME
   // should still be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(BOOKMARKS, client_tag));
-    node.SetTitle(UTF8ToWide("title2"));
+    node.SetTitle(base::UTF8ToWide("title2"));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
   }
   EXPECT_TRUE(ResetUnsyncedEntry(BOOKMARKS, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for non-bookmarks
 // when we write the same data, but does set it when we write new data.
@@ skipping 10 matching lines @@
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, client_tag));
-    node.SetTitle(UTF8ToWide(client_tag));
+    node.SetTitle(base::UTF8ToWide(client_tag));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, client_tag));
-    node.SetTitle(UTF8ToWide("title2"));
+    node.SetTitle(base::UTF8ToWide("title2"));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 }
 
 // Verify SetTitle(..) doesn't unnecessarily set IS_UNSYNCED for encrypted
 // non-bookmarks when we write the same data or when we write new data
 // data (should remained kEncryptedString).
 TEST_F(SyncManagerTest, SetNonBookmarkTitleWithEncryption) {
   std::string client_tag = "title";
   sync_pb::EntitySpecifics entity_specifics;
@@ skipping 20 matching lines @@
   PumpLoop();
   EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to the same title. Should not set is_unsynced.
   // NON_UNIQUE_NAME should be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, client_tag));
-    node.SetTitle(UTF8ToWide(client_tag));
+    node.SetTitle(base::UTF8ToWide(client_tag));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
   }
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, client_tag));
 
   // Manually change to new title. Should not set is_unsynced because the
   // NON_UNIQUE_NAME should still be kEncryptedString.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, client_tag));
-    node.SetTitle(UTF8ToWide("title2"));
+    node.SetTitle(base::UTF8ToWide("title2"));
     const syncable::Entry* node_entry = node.GetEntry();
     const sync_pb::EntitySpecifics& specifics = node_entry->GetSpecifics();
     EXPECT_TRUE(specifics.has_encrypted());
     EXPECT_EQ(kEncryptedString, node_entry->GetNonUniqueName());
     EXPECT_FALSE(node_entry->GetIsUnsynced());
   }
 }
 
 // Ensure that titles are truncated to 255 bytes, and attempting to reset
 // them to their longer version does not set IS_UNSYNCED.
@@ skipping 12 matching lines @@
                  entity_specifics);
   // New node shouldn't start off unsynced.
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
 
   // Manually change to the long title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, kClientTag));
-    node.SetTitle(UTF8ToWide(title));
+    node.SetTitle(base::UTF8ToWide(title));
     EXPECT_EQ(node.GetTitle(), title.substr(0, 255));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
 
   // Manually change to the same title. Should not set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, kClientTag));
-    node.SetTitle(UTF8ToWide(title));
+    node.SetTitle(base::UTF8ToWide(title));
     EXPECT_EQ(node.GetTitle(), title.substr(0, 255));
   }
   EXPECT_FALSE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
 
   // Manually change to new title. Should set is_unsynced.
   {
     WriteTransaction trans(FROM_HERE, sync_manager_.GetUserShare());
     WriteNode node(&trans);
     EXPECT_EQ(BaseNode::INIT_OK,
               node.InitByClientTagLookup(PREFERENCES, kClientTag));
-    node.SetTitle(UTF8ToWide("title2"));
+    node.SetTitle(base::UTF8ToWide("title2"));
   }
   EXPECT_TRUE(ResetUnsyncedEntry(PREFERENCES, kClientTag));
 }
 
 // Create an encrypted entry when the cryptographer doesn't think the type is
 // marked for encryption. Ensure reads/writes don't break and don't unencrypt
 // the data.
 TEST_F(SyncManagerTest, SetPreviouslyEncryptedSpecifics) {
   std::string client_tag = "tag";
   std::string url = "url";
@@ skipping 819 matching lines @@
 // SyncManagerInitInvalidStorageTest::GetFactory will return
 // DirectoryBackingStore that ensures that SyncManagerImpl::OpenDirectory fails.
 // SyncManagerImpl initialization is done in SyncManagerTest::SetUp. This test's
 // task is to ensure that SyncManagerImpl reported initialization failure in
 // OnInitializationComplete callback.
 TEST_F(SyncManagerInitInvalidStorageTest, FailToOpenDatabase) {
   EXPECT_FALSE(initialization_succeeded_);
 }
 
 }  // namespace