bookmark_utils.cc 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/bookmarks/browser/bookmark_utils.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <unordered_set>
  8. #include <utility>
  9. #include "base/bind.h"
  10. #include "base/containers/contains.h"
  11. #include "base/feature_list.h"
  12. #include "base/files/file_path.h"
  13. #include "base/guid.h"
  14. #include "base/i18n/case_conversion.h"
  15. #include "base/i18n/string_search.h"
  16. #include "base/metrics/user_metrics_action.h"
  17. #include "base/strings/string_util.h"
  18. #include "base/strings/stringprintf.h"
  19. #include "base/strings/utf_string_conversions.h"
  20. #include "base/time/time.h"
  21. #include "build/build_config.h"
  22. #include "components/bookmarks/browser/bookmark_client.h"
  23. #include "components/bookmarks/browser/bookmark_model.h"
  24. #include "components/bookmarks/browser/scoped_group_bookmark_actions.h"
  25. #include "components/bookmarks/common/bookmark_pref_names.h"
  26. #include "components/pref_registry/pref_registry_syncable.h"
  27. #include "components/prefs/pref_service.h"
  28. #include "components/query_parser/query_parser.h"
  29. #include "components/url_formatter/url_formatter.h"
  30. #include "ui/base/clipboard/clipboard.h"
  31. #include "ui/base/data_transfer_policy/data_transfer_endpoint.h"
  32. #include "ui/base/models/tree_node_iterator.h"
  33. #include "url/gurl.h"
  34. using base::Time;
  35. namespace bookmarks {
  36. namespace {
  37. // The maximum length of URL or title returned by the Cleanup functions.
  38. const size_t kCleanedUpUrlMaxLength = 1024u;
  39. const size_t kCleanedUpTitleMaxLength = 1024u;
  40. void CloneBookmarkNodeImpl(BookmarkModel* model,
  41. const BookmarkNodeData::Element& element,
  42. const BookmarkNode* parent,
  43. size_t index_to_add_at,
  44. bool reset_node_times) {
  45. // Make sure to not copy non clonable keys.
  46. BookmarkNode::MetaInfoMap meta_info_map = element.meta_info_map;
  47. for (const std::string& key : model->non_cloned_keys())
  48. meta_info_map.erase(key);
  49. if (element.is_url) {
  50. Time date_added = reset_node_times ? Time::Now() : element.date_added;
  51. DCHECK(!date_added.is_null());
  52. const BookmarkNode* node = model->AddNewURL(
  53. parent, index_to_add_at, element.title, element.url, &meta_info_map);
  54. model->SetDateAdded(node, date_added);
  55. } else {
  56. const BookmarkNode* cloned_node = model->AddFolder(
  57. parent, index_to_add_at, element.title, &meta_info_map);
  58. if (!reset_node_times) {
  59. DCHECK(!element.date_folder_modified.is_null());
  60. model->SetDateFolderModified(cloned_node, element.date_folder_modified);
  61. }
  62. for (int i = 0; i < static_cast<int>(element.children.size()); ++i)
  63. CloneBookmarkNodeImpl(model, element.children[i], cloned_node, i,
  64. reset_node_times);
  65. }
  66. }
  67. // Comparison function that compares based on date modified of the two nodes.
  68. bool MoreRecentlyModified(const BookmarkNode* n1, const BookmarkNode* n2) {
  69. return n1->date_folder_modified() > n2->date_folder_modified();
  70. }
  71. // Returns true if |text| contains each string in |words|. This is used when
  72. // searching for bookmarks.
  73. bool DoesBookmarkTextContainWords(const std::u16string& text,
  74. const std::vector<std::u16string>& words) {
  75. for (size_t i = 0; i < words.size(); ++i) {
  76. if (!base::i18n::StringSearchIgnoringCaseAndAccents(words[i], text, nullptr,
  77. nullptr)) {
  78. return false;
  79. }
  80. }
  81. return true;
  82. }
  83. // This is used with a tree iterator to skip subtrees which are not visible.
  84. bool PruneInvisibleFolders(const BookmarkNode* node) {
  85. return !node->IsVisible();
  86. }
  87. // This traces parents up to root, determines if node is contained in a
  88. // selected folder.
  89. bool HasSelectedAncestor(BookmarkModel* model,
  90. const std::vector<const BookmarkNode*>& selected_nodes,
  91. const BookmarkNode* node) {
  92. if (!node || model->is_permanent_node(node))
  93. return false;
  94. for (size_t i = 0; i < selected_nodes.size(); ++i)
  95. if (node->id() == selected_nodes[i]->id())
  96. return true;
  97. return HasSelectedAncestor(model, selected_nodes, node->parent());
  98. }
  99. const BookmarkNode* GetNodeByID(const BookmarkNode* node, int64_t id) {
  100. if (node->id() == id)
  101. return node;
  102. for (const auto& child : node->children()) {
  103. const BookmarkNode* result = GetNodeByID(child.get(), id);
  104. if (result)
  105. return result;
  106. }
  107. return nullptr;
  108. }
  109. // Attempts to shorten a URL safely (i.e., by preventing the end of the URL
  110. // from being in the middle of an escape sequence) to no more than
  111. // kCleanedUpUrlMaxLength characters, returning the result.
  112. std::string TruncateUrl(const std::string& url) {
  113. if (url.length() <= kCleanedUpUrlMaxLength)
  114. return url;
  115. // If we're in the middle of an escape sequence, truncate just before it.
  116. if (url[kCleanedUpUrlMaxLength - 1] == '%')
  117. return url.substr(0, kCleanedUpUrlMaxLength - 1);
  118. if (url[kCleanedUpUrlMaxLength - 2] == '%')
  119. return url.substr(0, kCleanedUpUrlMaxLength - 2);
  120. return url.substr(0, kCleanedUpUrlMaxLength);
  121. }
  122. // Returns the URL from the clipboard. If there is no URL an empty URL is
  123. // returned.
  124. GURL GetUrlFromClipboard(bool notify_if_restricted) {
  125. std::u16string url_text;
  126. #if !BUILDFLAG(IS_IOS)
  127. ui::DataTransferEndpoint data_dst = ui::DataTransferEndpoint(
  128. ui::EndpointType::kDefault, notify_if_restricted);
  129. ui::Clipboard::GetForCurrentThread()->ReadText(
  130. ui::ClipboardBuffer::kCopyPaste, &data_dst, &url_text);
  131. #endif
  132. return GURL(url_text);
  133. }
  134. template <class type>
  135. void GetBookmarksMatchingPropertiesImpl(
  136. type& iterator,
  137. BookmarkModel* model,
  138. const QueryFields& query,
  139. const std::vector<std::u16string>& query_words,
  140. size_t max_count,
  141. std::vector<const BookmarkNode*>* nodes) {
  142. while (iterator.has_next()) {
  143. const BookmarkNode* node = iterator.Next();
  144. if ((!query_words.empty() &&
  145. !DoesBookmarkContainWords(node->GetTitle(), node->url(),
  146. query_words)) ||
  147. model->is_permanent_node(node)) {
  148. continue;
  149. }
  150. if (query.title && node->GetTitle() != *query.title)
  151. continue;
  152. nodes->push_back(node);
  153. if (nodes->size() == max_count)
  154. return;
  155. }
  156. }
  157. #if BUILDFLAG(IS_ANDROID)
  158. // Returns whether or not a bookmark model contains any bookmarks aside of the
  159. // permanent nodes.
  160. bool HasUserCreatedBookmarks(BookmarkModel* model) {
  161. const BookmarkNode* root_node = model->root_node();
  162. return std::any_of(
  163. root_node->children().cbegin(), root_node->children().cend(),
  164. [](const auto& node) { return !node->children().empty(); });
  165. }
  166. #endif
  167. } // namespace
  168. QueryFields::QueryFields() {}
  169. QueryFields::~QueryFields() {}
  170. VectorIterator::VectorIterator(std::vector<const BookmarkNode*>* nodes)
  171. : nodes_(nodes), current_(nodes->begin()) {}
  172. VectorIterator::~VectorIterator() = default;
  173. bool VectorIterator::has_next() {
  174. return (current_ != nodes_->end());
  175. }
  176. const BookmarkNode* VectorIterator::Next() {
  177. const BookmarkNode* result = *current_;
  178. ++current_;
  179. return result;
  180. }
  181. void CloneBookmarkNode(BookmarkModel* model,
  182. const std::vector<BookmarkNodeData::Element>& elements,
  183. const BookmarkNode* parent,
  184. size_t index_to_add_at,
  185. bool reset_node_times) {
  186. if (!parent->is_folder() || !model) {
  187. NOTREACHED();
  188. return;
  189. }
  190. for (size_t i = 0; i < elements.size(); ++i) {
  191. CloneBookmarkNodeImpl(model, elements[i], parent, index_to_add_at + i,
  192. reset_node_times);
  193. }
  194. }
  195. void CopyToClipboard(BookmarkModel* model,
  196. const std::vector<const BookmarkNode*>& nodes,
  197. bool remove_nodes) {
  198. if (nodes.empty())
  199. return;
  200. // Create array of selected nodes with descendants filtered out.
  201. std::vector<const BookmarkNode*> filtered_nodes;
  202. for (const auto* node : nodes) {
  203. if (!HasSelectedAncestor(model, nodes, node->parent()))
  204. filtered_nodes.push_back(node);
  205. }
  206. BookmarkNodeData(filtered_nodes).WriteToClipboard();
  207. if (remove_nodes) {
  208. ScopedGroupBookmarkActions group_cut(model);
  209. for (const auto* node : filtered_nodes)
  210. model->Remove(node);
  211. }
  212. }
  213. // Updates |title| such that |url| and |title| pair are unique among the
  214. // children of |parent|.
  215. void MakeTitleUnique(const BookmarkModel* model,
  216. const BookmarkNode* parent,
  217. const GURL& url,
  218. std::u16string* title) {
  219. std::unordered_set<std::u16string> titles;
  220. std::u16string original_title_lower = base::i18n::ToLower(*title);
  221. for (const auto& node : parent->children()) {
  222. if (node->is_url() && (url == node->url()) &&
  223. base::StartsWith(base::i18n::ToLower(node->GetTitle()),
  224. original_title_lower,
  225. base::CompareCase::SENSITIVE)) {
  226. titles.insert(node->GetTitle());
  227. }
  228. }
  229. if (titles.find(*title) == titles.end())
  230. return;
  231. for (size_t i = 0; i < titles.size(); i++) {
  232. const std::u16string new_title(*title +
  233. base::ASCIIToUTF16(base::StringPrintf(
  234. " (%lu)", (unsigned long)(i + 1))));
  235. if (titles.find(new_title) == titles.end()) {
  236. *title = new_title;
  237. return;
  238. }
  239. }
  240. NOTREACHED();
  241. }
  242. void PasteFromClipboard(BookmarkModel* model,
  243. const BookmarkNode* parent,
  244. size_t index) {
  245. if (!parent)
  246. return;
  247. BookmarkNodeData bookmark_data;
  248. if (!bookmark_data.ReadFromClipboard(ui::ClipboardBuffer::kCopyPaste)) {
  249. GURL url = GetUrlFromClipboard(/*notify_if_restricted=*/true);
  250. if (!url.is_valid())
  251. return;
  252. BookmarkNode node(/*id=*/0, base::GUID::GenerateRandomV4(), url);
  253. node.SetTitle(base::ASCIIToUTF16(url.spec()));
  254. bookmark_data = BookmarkNodeData(&node);
  255. }
  256. DCHECK_LE(index, parent->children().size());
  257. ScopedGroupBookmarkActions group_paste(model);
  258. if (bookmark_data.size() == 1 &&
  259. model->IsBookmarked(bookmark_data.elements[0].url)) {
  260. MakeTitleUnique(model,
  261. parent,
  262. bookmark_data.elements[0].url,
  263. &bookmark_data.elements[0].title);
  264. }
  265. CloneBookmarkNode(model, bookmark_data.elements, parent, index, true);
  266. }
  267. bool CanPasteFromClipboard(BookmarkModel* model, const BookmarkNode* node) {
  268. if (!node || !model->client()->CanBeEditedByUser(node))
  269. return false;
  270. return (BookmarkNodeData::ClipboardContainsBookmarks() ||
  271. GetUrlFromClipboard(/*notify_if_restricted=*/false).is_valid());
  272. }
  273. std::vector<const BookmarkNode*> GetMostRecentlyModifiedUserFolders(
  274. BookmarkModel* model,
  275. size_t max_count) {
  276. std::vector<const BookmarkNode*> nodes;
  277. ui::TreeNodeIterator<const BookmarkNode> iterator(
  278. model->root_node(), base::BindRepeating(&PruneInvisibleFolders));
  279. while (iterator.has_next()) {
  280. const BookmarkNode* parent = iterator.Next();
  281. if (!model->client()->CanBeEditedByUser(parent))
  282. continue;
  283. if (parent->is_folder() && parent->date_folder_modified() > Time()) {
  284. if (max_count == 0) {
  285. nodes.push_back(parent);
  286. } else {
  287. auto i = std::upper_bound(nodes.begin(), nodes.end(), parent,
  288. &MoreRecentlyModified);
  289. if (nodes.size() < max_count || i != nodes.end()) {
  290. nodes.insert(i, parent);
  291. while (nodes.size() > max_count)
  292. nodes.pop_back();
  293. }
  294. }
  295. } // else case, the root node, which we don't care about or imported nodes
  296. // (which have a time of 0).
  297. }
  298. if (nodes.size() < max_count) {
  299. // Add the permanent nodes if there is space. The permanent nodes are the
  300. // only children of the root_node.
  301. const BookmarkNode* root_node = model->root_node();
  302. for (const auto& node : root_node->children()) {
  303. if (node->IsVisible() && model->client()->CanBeEditedByUser(node.get()) &&
  304. !base::Contains(nodes, node.get())) {
  305. nodes.push_back(node.get());
  306. if (nodes.size() == max_count)
  307. break;
  308. }
  309. }
  310. }
  311. return nodes;
  312. }
  313. void GetMostRecentlyAddedEntries(BookmarkModel* model,
  314. size_t count,
  315. std::vector<const BookmarkNode*>* nodes) {
  316. ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
  317. while (iterator.has_next()) {
  318. const BookmarkNode* node = iterator.Next();
  319. if (node->is_url()) {
  320. auto insert_position = std::upper_bound(nodes->begin(), nodes->end(),
  321. node, &MoreRecentlyAdded);
  322. if (nodes->size() < count || insert_position != nodes->end()) {
  323. nodes->insert(insert_position, node);
  324. while (nodes->size() > count)
  325. nodes->pop_back();
  326. }
  327. }
  328. }
  329. }
  330. bool MoreRecentlyAdded(const BookmarkNode* n1, const BookmarkNode* n2) {
  331. return n1->date_added() > n2->date_added();
  332. }
  333. void GetBookmarksMatchingProperties(BookmarkModel* model,
  334. const QueryFields& query,
  335. size_t max_count,
  336. std::vector<const BookmarkNode*>* nodes) {
  337. std::vector<std::u16string> query_words = ParseBookmarkQuery(query);
  338. if (query.word_phrase_query && query_words.empty())
  339. return;
  340. if (query.url) {
  341. // Shortcut into the BookmarkModel if searching for URL.
  342. GURL url(*query.url);
  343. std::vector<const BookmarkNode*> url_matched_nodes;
  344. if (url.is_valid())
  345. model->GetNodesByURL(url, &url_matched_nodes);
  346. VectorIterator iterator(&url_matched_nodes);
  347. GetBookmarksMatchingPropertiesImpl<VectorIterator>(
  348. iterator, model, query, query_words, max_count, nodes);
  349. } else {
  350. ui::TreeNodeIterator<const BookmarkNode> iterator(model->root_node());
  351. GetBookmarksMatchingPropertiesImpl<
  352. ui::TreeNodeIterator<const BookmarkNode>>(
  353. iterator, model, query, query_words, max_count, nodes);
  354. }
  355. }
  356. // Parses the provided query and returns a vector of query words.
  357. std::vector<std::u16string> ParseBookmarkQuery(
  358. const bookmarks::QueryFields& query) {
  359. std::vector<std::u16string> query_words;
  360. if (query.word_phrase_query) {
  361. query_parser::QueryParser::ParseQueryWords(
  362. base::i18n::ToLower(*query.word_phrase_query),
  363. query_parser::MatchingAlgorithm::DEFAULT, &query_words);
  364. }
  365. return query_words;
  366. }
  367. // Returns true if |node|s title or url contains the strings in |words|.
  368. bool DoesBookmarkContainWords(const std::u16string& title,
  369. const GURL& url,
  370. const std::vector<std::u16string>& words) {
  371. return DoesBookmarkTextContainWords(title, words) ||
  372. DoesBookmarkTextContainWords(base::UTF8ToUTF16(url.spec()), words) ||
  373. DoesBookmarkTextContainWords(
  374. url_formatter::FormatUrl(url, url_formatter::kFormatUrlOmitNothing,
  375. base::UnescapeRule::NORMAL, nullptr,
  376. nullptr, nullptr),
  377. words);
  378. }
  379. void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
  380. registry->RegisterBooleanPref(
  381. prefs::kShowBookmarkBar, false,
  382. user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
  383. registry->RegisterBooleanPref(prefs::kEditBookmarksEnabled, true);
  384. registry->RegisterBooleanPref(
  385. prefs::kShowAppsShortcutInBookmarkBar, false,
  386. user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
  387. registry->RegisterBooleanPref(
  388. prefs::kShowManagedBookmarksInBookmarkBar, true,
  389. user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
  390. RegisterManagedBookmarksPrefs(registry);
  391. }
  392. void RegisterManagedBookmarksPrefs(PrefRegistrySimple* registry) {
  393. // Don't sync this, as otherwise, due to a limitation in sync, it
  394. // will cause a deadlock (see http://crbug.com/97955). If we truly
  395. // want to sync the expanded state of folders, it should be part of
  396. // bookmark sync itself (i.e., a property of the sync folder nodes).
  397. registry->RegisterListPref(prefs::kBookmarkEditorExpandedNodes);
  398. registry->RegisterListPref(prefs::kManagedBookmarks);
  399. registry->RegisterStringPref(
  400. prefs::kManagedBookmarksFolderName, std::string());
  401. }
  402. const BookmarkNode* GetParentForNewNodes(
  403. const BookmarkNode* parent,
  404. const std::vector<const BookmarkNode*>& selection,
  405. size_t* index) {
  406. const BookmarkNode* real_parent = parent;
  407. if (selection.size() == 1 && selection[0]->is_folder())
  408. real_parent = selection[0];
  409. if (index) {
  410. if (selection.size() == 1 && selection[0]->is_url()) {
  411. absl::optional<size_t> selection_index =
  412. real_parent->GetIndexOf(selection[0]);
  413. DCHECK(selection_index.has_value());
  414. *index = selection_index.value() + 1;
  415. } else {
  416. *index = real_parent->children().size();
  417. }
  418. }
  419. return real_parent;
  420. }
  421. void DeleteBookmarkFolders(BookmarkModel* model,
  422. const std::vector<int64_t>& ids) {
  423. // Remove the folders that were removed. This has to be done after all the
  424. // other changes have been committed.
  425. for (auto iter = ids.begin(); iter != ids.end(); ++iter) {
  426. const BookmarkNode* node = GetBookmarkNodeByID(model, *iter);
  427. if (!node)
  428. continue;
  429. model->Remove(node);
  430. }
  431. }
  432. const BookmarkNode* AddIfNotBookmarked(BookmarkModel* model,
  433. const GURL& url,
  434. const std::u16string& title) {
  435. // Nothing to do, a user bookmark with that url already exists.
  436. if (IsBookmarkedByUser(model, url))
  437. return nullptr;
  438. model->client()->RecordAction(base::UserMetricsAction("BookmarkAdded"));
  439. const BookmarkNode* parent = GetParentForNewNodes(model);
  440. return model->AddNewURL(parent, parent->children().size(), title, url);
  441. }
  442. void RemoveAllBookmarks(BookmarkModel* model, const GURL& url) {
  443. std::vector<const BookmarkNode*> bookmarks;
  444. model->GetNodesByURL(url, &bookmarks);
  445. // Remove all the user bookmarks.
  446. for (size_t i = 0; i < bookmarks.size(); ++i) {
  447. const BookmarkNode* node = bookmarks[i];
  448. if (model->client()->CanBeEditedByUser(node))
  449. model->Remove(node);
  450. }
  451. }
  452. std::u16string CleanUpUrlForMatching(
  453. const GURL& gurl,
  454. base::OffsetAdjuster::Adjustments* adjustments) {
  455. base::OffsetAdjuster::Adjustments tmp_adjustments;
  456. return base::i18n::ToLower(url_formatter::FormatUrlWithAdjustments(
  457. GURL(TruncateUrl(gurl.spec())),
  458. url_formatter::kFormatUrlOmitUsernamePassword,
  459. base::UnescapeRule::SPACES | base::UnescapeRule::PATH_SEPARATORS |
  460. base::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS,
  461. nullptr, nullptr, adjustments ? adjustments : &tmp_adjustments));
  462. }
  463. std::u16string CleanUpTitleForMatching(const std::u16string& title) {
  464. return base::i18n::ToLower(title.substr(0u, kCleanedUpTitleMaxLength));
  465. }
  466. bool CanAllBeEditedByUser(BookmarkClient* client,
  467. const std::vector<const BookmarkNode*>& nodes) {
  468. for (size_t i = 0; i < nodes.size(); ++i) {
  469. if (!client->CanBeEditedByUser(nodes[i]))
  470. return false;
  471. }
  472. return true;
  473. }
  474. bool IsBookmarkedByUser(BookmarkModel* model, const GURL& url) {
  475. std::vector<const BookmarkNode*> nodes;
  476. model->GetNodesByURL(url, &nodes);
  477. for (size_t i = 0; i < nodes.size(); ++i) {
  478. if (model->client()->CanBeEditedByUser(nodes[i]))
  479. return true;
  480. }
  481. return false;
  482. }
  483. const BookmarkNode* GetBookmarkNodeByID(const BookmarkModel* model,
  484. int64_t id) {
  485. // TODO(sky): TreeNode needs a method that visits all nodes using a predicate.
  486. return GetNodeByID(model->root_node(), id);
  487. }
  488. bool IsDescendantOf(const BookmarkNode* node, const BookmarkNode* root) {
  489. return node && node->HasAncestor(root);
  490. }
  491. bool HasDescendantsOf(const std::vector<const BookmarkNode*>& list,
  492. const BookmarkNode* root) {
  493. for (const BookmarkNode* node : list) {
  494. if (IsDescendantOf(node, root))
  495. return true;
  496. }
  497. return false;
  498. }
  499. const BookmarkNode* GetParentForNewNodes(BookmarkModel* model) {
  500. #if BUILDFLAG(IS_ANDROID)
  501. if (!HasUserCreatedBookmarks(model))
  502. return model->mobile_node();
  503. #endif
  504. std::vector<const BookmarkNode*> nodes =
  505. GetMostRecentlyModifiedUserFolders(model, 1);
  506. DCHECK(!nodes.empty()); // This list is always padded with default folders.
  507. return nodes[0];
  508. }
  509. } // namespace bookmarks