Replace string16 with base::string16.

chrome/browser/bookmarks/bookmark_model.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/bookmarks/bookmark_model.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 52 matching lines @@
 }
 
 BookmarkNode::BookmarkNode(int64 id, const GURL& url)
     : url_(url) {
   Initialize(id);
 }
 
 BookmarkNode::~BookmarkNode() {
 }
 
-void BookmarkNode::SetTitle(const string16& title) {
+void BookmarkNode::SetTitle(const base::string16& title) {
   // Replace newlines and other problematic whitespace characters in
   // folder/bookmark names with spaces.
-  string16 trimmed_title;
+  base::string16 trimmed_title;
   base::ReplaceChars(title, kInvalidChars, ASCIIToUTF16(" "), &trimmed_title);
   ui::TreeNode<BookmarkNode>::SetTitle(trimmed_title);
 }
 
 bool BookmarkNode::IsVisible() const {
   return true;
 }
 
 bool BookmarkNode::GetMetaInfo(const std::string& key,
                                std::string* value) const {
@@ skipping 304 matching lines @@
 const gfx::Image& BookmarkModel::GetFavicon(const BookmarkNode* node) {
   DCHECK(node);
   if (node->favicon_state() == BookmarkNode::INVALID_FAVICON) {
     BookmarkNode* mutable_node = AsMutable(node);
     mutable_node->set_favicon_state(BookmarkNode::LOADING_FAVICON);
     LoadFavicon(mutable_node);
   }
   return node->favicon();
 }
 
-void BookmarkModel::SetTitle(const BookmarkNode* node, const string16& title) {
+void BookmarkModel::SetTitle(const BookmarkNode* node, const base::string16& title) {
   if (!node) {
     NOTREACHED();
     return;
   }
   if (node->GetTitle() == title)
     return;
 
   if (is_permanent_node(node)) {
     NOTREACHED();
     return;
@@ skipping 183 matching lines @@
   loaded_signal_.Wait();
 }
 
 const BookmarkNode* BookmarkModel::GetNodeByID(int64 id) const {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(&root_, id);
 }
 
 const BookmarkNode* BookmarkModel::AddFolder(const BookmarkNode* parent,
                                              int index,
-                                             const string16& title) {
+                                             const base::string16& title) {
   if (!loaded_ || is_root_node(parent) || !IsValidIndex(parent, index, true)) {
     // Can't add to the root.
     NOTREACHED();
     return NULL;
   }
 
   BookmarkNode* new_node = new BookmarkNode(generate_next_node_id(), GURL());
   new_node->set_date_folder_modified(Time::Now());
   // Folders shouldn't have line breaks in their titles.
   new_node->SetTitle(title);
   new_node->set_type(BookmarkNode::FOLDER);
 
   return AddNode(AsMutable(parent), index, new_node);
 }
 
 const BookmarkNode* BookmarkModel::AddURL(const BookmarkNode* parent,
                                           int index,
-                                          const string16& title,
+                                          const base::string16& title,
                                           const GURL& url) {
   return AddURLWithCreationTime(parent, index,
                                 CollapseWhitespace(title, false),
                                 url, Time::Now());
 }
 
 const BookmarkNode* BookmarkModel::AddURLWithCreationTime(
     const BookmarkNode* parent,
     int index,
-    const string16& title,
+    const base::string16& title,
     const GURL& url,
     const Time& creation_time) {
   if (!loaded_ || !url.is_valid() || is_root_node(parent) ||
       !IsValidIndex(parent, index, true)) {
     NOTREACHED();
     return NULL;
   }
 
   // Syncing may result in dates newer than the last modified date.
   if (creation_time > parent->date_folder_modified())
@@ skipping 66 matching lines @@
 
   if (store_.get())
     store_->ScheduleSave();
 }
 
 void BookmarkModel::ResetDateFolderModified(const BookmarkNode* node) {
   SetDateFolderModified(node, Time());
 }
 
 void BookmarkModel::GetBookmarksWithTitlesMatching(
-    const string16& text,
+    const base::string16& text,
     size_t max_count,
     std::vector<BookmarkTitleMatch>* matches) {
   if (!loaded_)
     return;
 
   index_->GetBookmarksWithTitlesMatching(text, max_count, matches);
 }
 
 void BookmarkModel::ClearStore() {
   registrar_.RemoveAll();
@@ skipping 327 matching lines @@
   BookmarkPermanentNode* bb_node =
       CreatePermanentNode(BookmarkNode::BOOKMARK_BAR);
   BookmarkPermanentNode* other_node =
       CreatePermanentNode(BookmarkNode::OTHER_NODE);
   BookmarkPermanentNode* mobile_node =
       CreatePermanentNode(BookmarkNode::MOBILE);
   return new BookmarkLoadDetails(bb_node, other_node, mobile_node,
                                  new BookmarkIndex(profile_),
                                  next_node_id_);
 }