Update some uses of UTF conversions in chrome/browser to use the base:: namespace.

chrome/browser/sync/test/integration/bookmarks_helper.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.
 
 #include "chrome/browser/sync/test/integration/bookmarks_helper.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
@@ skipping 409 matching lines @@
                            const BookmarkNode* parent,
                            int index,
                            const std::wstring& title,
                            const GURL& url) {
   if (GetBookmarkModel(profile)->GetNodeByID(parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
   const BookmarkNode* result = GetBookmarkModel(profile)->
-      AddURL(parent, index, WideToUTF16(title), url);
+      AddURL(parent, index, base::WideToUTF16(title), url);
   if (!result) {
     LOG(ERROR) << "Could not add bookmark " << title << " to Profile "
                << profile;
     return NULL;
   }
   if (test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
     FindNodeInVerifier(GetBookmarkModel(profile), parent, &v_parent);
     const BookmarkNode* v_node = GetVerifierBookmarkModel()->
-        AddURL(v_parent, index, WideToUTF16(title), url);
+        AddURL(v_parent, index, base::WideToUTF16(title), url);
     if (!v_node) {
       LOG(ERROR) << "Could not add bookmark " << title << " to the verifier";
       return NULL;
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
 const BookmarkNode* AddFolder(int profile,
                               const std::wstring& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), 0, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               int index,
                               const std::wstring& title) {
   return AddFolder(profile, GetBookmarkBarNode(profile), index, title);
 }
 
 const BookmarkNode* AddFolder(int profile,
                               const BookmarkNode* parent,
                               int index,
                               const std::wstring& title) {
   if (GetBookmarkModel(profile)->GetNodeByID(parent->id()) != parent) {
     LOG(ERROR) << "Node " << parent->GetTitle() << " does not belong to "
                << "Profile " << profile;
     return NULL;
   }
-  const BookmarkNode* result =
-      GetBookmarkModel(profile)->AddFolder(parent, index, WideToUTF16(title));
+  const BookmarkNode* result = GetBookmarkModel(profile)->AddFolder(
+      parent, index, base::WideToUTF16(title));
   EXPECT_TRUE(result);
   if (!result) {
     LOG(ERROR) << "Could not add folder " << title << " to Profile "
                << profile;
     return NULL;
   }
   if (test()->use_verifier()) {
     const BookmarkNode* v_parent = NULL;
     FindNodeInVerifier(GetBookmarkModel(profile), parent, &v_parent);
     const BookmarkNode* v_node = GetVerifierBookmarkModel()->AddFolder(
-        v_parent, index, WideToUTF16(title));
+        v_parent, index, base::WideToUTF16(title));
     if (!v_node) {
       LOG(ERROR) << "Could not add folder " << title << " to the verifier";
       return NULL;
     }
     EXPECT_TRUE(NodesMatch(v_node, result));
   }
   return result;
 }
 
 void SetTitle(int profile,
               const BookmarkNode* node,
               const std::wstring& new_title) {
   ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
   if (test()->use_verifier()) {
     const BookmarkNode* v_node = NULL;
     FindNodeInVerifier(GetBookmarkModel(profile), node, &v_node);
-    GetVerifierBookmarkModel()->SetTitle(v_node, WideToUTF16(new_title));
+    GetVerifierBookmarkModel()->SetTitle(v_node, base::WideToUTF16(new_title));
   }
-  GetBookmarkModel(profile)->SetTitle(node, WideToUTF16(new_title));
+  GetBookmarkModel(profile)->SetTitle(node, base::WideToUTF16(new_title));
 }
 
 void SetFavicon(int profile,
                 const BookmarkNode* node,
                 const GURL& icon_url,
                 const gfx::Image& image,
                 FaviconSource favicon_source) {
   ASSERT_EQ(GetBookmarkModel(profile)->GetNodeByID(node->id()), node)
       << "Node " << node->GetTitle() << " does not belong to "
       << "Profile " << profile;
@@ skipping 177 matching lines @@
   GetBookmarkModel(profile)->GetNodesByURL(url, &nodes);
   EXPECT_EQ(1U, nodes.size());
   if (nodes.empty())
     return NULL;
   return nodes[0];
 }
 
 int CountBookmarksWithTitlesMatching(int profile, const std::wstring& title) {
   return CountNodesWithTitlesMatching(GetBookmarkModel(profile),
                                       BookmarkNode::URL,
-                                      WideToUTF16(title));
+                                      base::WideToUTF16(title));
 }
 
 int CountFoldersWithTitlesMatching(int profile, const std::wstring& title) {
   return CountNodesWithTitlesMatching(GetBookmarkModel(profile),
                                       BookmarkNode::FOLDER,
-                                      WideToUTF16(title));
+                                      base::WideToUTF16(title));
 }
 
 gfx::Image CreateFavicon(SkColor color) {
   const int dip_width = 16;
   const int dip_height = 16;
   std::vector<ui::ScaleFactor> favicon_scale_factors =
       FaviconUtil::GetFaviconScaleFactors();
   gfx::ImageSkia favicon;
   for (size_t i = 0; i < favicon_scale_factors.size(); ++i) {
     float scale = ui::GetImageScale(favicon_scale_factors[i]);
@@ skipping 40 matching lines @@
 
 std::wstring IndexedSubfolderName(int i) {
   return base::StringPrintf(L"Subfolder Name %d", i);
 }
 
 std::wstring IndexedSubsubfolderName(int i) {
   return base::StringPrintf(L"Subsubfolder Name %d", i);
 }
 
 }  // namespace bookmarks_helper