Cleaned up includes and unused declarations in the bookmarks component.

components/bookmarks/core/browser/bookmark_utils.cc

 // Copyright 2014 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 "components/bookmarks/core/browser/bookmark_utils.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/string_search.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/prefs/pref_service.h"
-#include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/bookmarks/core/browser/bookmark_model.h"
 #include "components/bookmarks/core/browser/scoped_group_bookmark_actions.h"
 #include "components/bookmarks/core/common/bookmark_pref_names.h"
 #include "components/query_parser/query_parser.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "net/base/net_util.h"
 #include "ui/base/models/tree_node_iterator.h"
 #include "url/gurl.h"
 
 using base::Time;
 
 namespace {
 
 // The maximum length of URL or title returned by the Cleanup functions.
 const size_t kCleanedUpUrlMaxLength = 1024u;
 const size_t kCleanedUpTitleMaxLength = 1024u;
 
 void CloneBookmarkNodeImpl(BookmarkModel* model,
                            const BookmarkNodeData::Element& element,
                            const BookmarkNode* parent,
                            int index_to_add_at,
                            bool reset_node_times) {
   if (element.is_url) {
-    base::Time date_added = reset_node_times ? Time::Now() : element.date_added;
+    Time date_added = reset_node_times ? Time::Now() : element.date_added;
     DCHECK(!date_added.is_null());
 
     model->AddURLWithCreationTimeAndMetaInfo(parent,
                                              index_to_add_at,
                                              element.title,
                                              element.url,
                                              date_added,
                                              &element.meta_info_map);
   } else {
     const BookmarkNode* cloned_node = model->AddFolderWithMetaInfo(
@@ skipping 160 matching lines @@
 
 std::vector<const BookmarkNode*> GetMostRecentlyModifiedFolders(
     BookmarkModel* model,
     size_t max_count) {
   std::vector<const BookmarkNode*> nodes;
   ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node(),
                                                     PruneInvisibleFolders);
 
   while (iterator.has_next()) {
     const BookmarkNode* parent = iterator.Next();
-    if (parent->is_folder() && parent->date_folder_modified() > base::Time()) {
+    if (parent->is_folder() && parent->date_folder_modified() > Time()) {
       if (max_count == 0) {
         nodes.push_back(parent);
       } else {
         std::vector<const BookmarkNode*>::iterator i =
             std::upper_bound(nodes.begin(), nodes.end(), parent,
                              &MoreRecentlyModified);
         if (nodes.size() < max_count || i != nodes.end()) {
           nodes.insert(i, parent);
           while (nodes.size() > max_count)
             nodes.pop_back();
@@ skipping 182 matching lines @@
 base::string16 CleanUpTitleForMatching(const base::string16& title) {
   return base::i18n::ToLower(title.substr(0u, kCleanedUpTitleMaxLength));
 }
 
 }  // namespace bookmark_utils
 
 const BookmarkNode* GetBookmarkNodeByID(const BookmarkModel* model, int64 id) {
   // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
   return GetNodeByID(model->root_node(), id);
 }