[NTP] Cleanup: add brackets in components/ntp_snippets. [1/2]

components/ntp_snippets/bookmarks/bookmark_last_visit_utils.cc

 // Copyright 2016 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/ntp_snippets/bookmarks/bookmark_last_visit_utils.h"
 
 #include <algorithm>
 #include <numeric>
 #include <set>
 #include <string>
@@ skipping 28 matching lines @@
 const char kBookmarkDismissedFromNTP[] = "dismissed_from_ntp";
 
 std::string FormatLastVisitDate(const base::Time& date) {
   return base::Int64ToString(date.ToInternalValue());
 }
 
 bool ExtractLastVisitDate(const BookmarkNode& node,
                  const std::string& meta_info_key,
                  base::Time* out) {
   std::string last_visit_date_string;
-  if (!node.GetMetaInfo(meta_info_key, &last_visit_date_string))
+  if (!node.GetMetaInfo(meta_info_key, &last_visit_date_string)) {
     return false;
+  }
 
   int64_t date = 0;
-  if (!base::StringToInt64(last_visit_date_string, &date) || date < 0)
+  if (!base::StringToInt64(last_visit_date_string, &date) || date < 0) {
     return false;
+  }
 
   *out = base::Time::FromInternalValue(date);
   return true;
 }
 
 bool IsBlacklisted(const GURL& url) {
   for (const char* blacklisted : kBookmarksURLBlacklist) {
-    if (url.spec() == blacklisted)
+    if (url.spec() == blacklisted) {
       return true;
+    }
   }
   return false;
 }
 
 std::vector<const BookmarkNode*>::const_iterator FindMostRecentBookmark(
     const std::vector<const BookmarkNode*>& bookmarks,
     bool creation_date_fallback,
     bool consider_visits_from_desktop) {
   auto most_recent = bookmarks.end();
   base::Time most_recent_last_visited = base::Time::UnixEpoch();
@@ skipping 11 matching lines @@
 
   return most_recent;
 }
 
 }  // namespace
 
 void UpdateBookmarkOnURLVisitedInMainFrame(BookmarkModel* bookmark_model,
                                            const GURL& url,
                                            bool is_mobile_platform) {
   // Skip URLs that are blacklisted.
-  if (IsBlacklisted(url))
+  if (IsBlacklisted(url)) {
     return;
+  }
 
   // Skip URLs that are not bookmarked.
   std::vector<const BookmarkNode*> bookmarks_for_url;
   bookmark_model->GetNodesByURL(url, &bookmarks_for_url);
-  if (bookmarks_for_url.empty())
+  if (bookmarks_for_url.empty()) {
     return;
+  }
 
   // If there are bookmarks for |url|, set their last visit date to now.
   std::string now = FormatLastVisitDate(base::Time::Now());
   for (const BookmarkNode* node : bookmarks_for_url) {
     bookmark_model->SetNodeMetaInfo(
         node, is_mobile_platform ? kBookmarkLastVisitDateOnMobileKey
                                  : kBookmarkLastVisitDateOnDesktopKey,
         now);
     // If the bookmark has been dismissed from NTP before, a new visit overrides
     // such a dismissal.
@@ skipping 30 matching lines @@
     *out = node->date_added();
     return true;
   }
 
   return got_mobile_date;
 }
 
 void MarkBookmarksDismissed(BookmarkModel* bookmark_model, const GURL& url) {
   std::vector<const BookmarkNode*> nodes;
   bookmark_model->GetNodesByURL(url, &nodes);
-  for (const BookmarkNode* node : nodes)
+  for (const BookmarkNode* node : nodes) {
     bookmark_model->SetNodeMetaInfo(node, kBookmarkDismissedFromNTP, "1");
+  }
 }
 
 bool IsDismissedFromNTPForBookmark(const BookmarkNode* node) {
-  if (!node)
+  if (!node) {
     return false;
+  }
 
   std::string dismissed_from_ntp;
   bool result =
       node->GetMetaInfo(kBookmarkDismissedFromNTP, &dismissed_from_ntp);
   DCHECK(!result || dismissed_from_ntp == "1");
   return result;
 }
 
 void MarkAllBookmarksUndismissed(BookmarkModel* bookmark_model) {
   // Get all the bookmark URLs.
   std::vector<BookmarkModel::URLAndTitle> bookmarks;
   bookmark_model->GetBookmarks(&bookmarks);
 
   // Remove dismissed flag from all bookmarks
   for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
     std::vector<const BookmarkNode*> nodes;
     bookmark_model->GetNodesByURL(bookmark.url, &nodes);
-    for (const BookmarkNode* node : nodes)
+    for (const BookmarkNode* node : nodes) {
       bookmark_model->DeleteNodeMetaInfo(node, kBookmarkDismissedFromNTP);
+    }
   }
 }
 
 std::vector<const BookmarkNode*> GetRecentlyVisitedBookmarks(
     BookmarkModel* bookmark_model,
     int min_count,
     int max_count,
     const base::Time& min_visit_time,
     bool creation_date_fallback,
     bool consider_visits_from_desktop) {
@@ skipping 75 matching lines @@
   std::vector<const BookmarkNode*> result;
   for (const RecentBookmark& bookmark : bookmarks) {
     // TODO(jkrcal): The following break rule is in conflict with the comment
     // and code above that we give at least |min_count| bookmarks (irrespective
     // of creation_date_fallback). Discuss with treib@ and clear up.
     if (!creation_date_fallback && bookmark.last_visited < min_visit_time) {
       break;
     }
 
     result.push_back(bookmark.node);
-    if (result.size() >= static_cast<size_t>(max_count))
+    if (result.size() >= static_cast<size_t>(max_count)) {
       break;
+    }
   }
   return result;
 }
 
 std::vector<const BookmarkNode*> GetDismissedBookmarksForDebugging(
     BookmarkModel* bookmark_model) {
   // Get all the bookmark URLs.
   std::vector<BookmarkModel::URLAndTitle> bookmarks;
   bookmark_model->GetBookmarks(&bookmarks);
 
   // Remove the bookmark URLs which have at least one non-dismissed bookmark.
   bookmarks.erase(
       std::remove_if(
           bookmarks.begin(), bookmarks.end(),
           [&bookmark_model](const BookmarkModel::URLAndTitle& bookmark) {
             std::vector<const BookmarkNode*> bookmarks_for_url;
             bookmark_model->GetNodesByURL(bookmark.url, &bookmarks_for_url);
             DCHECK(!bookmarks_for_url.empty());
 
             for (const BookmarkNode* node : bookmarks_for_url) {
-              if (!IsDismissedFromNTPForBookmark(node))
+              if (!IsDismissedFromNTPForBookmark(node)) {
                 return true;
+              }
             }
             return false;
           }),
       bookmarks.end());
 
   // Insert into |result|.
   std::vector<const BookmarkNode*> result;
   for (const BookmarkModel::URLAndTitle& bookmark : bookmarks) {
     result.push_back(
         bookmark_model->GetMostRecentlyAddedUserNodeForURL(bookmark.url));
@@ skipping 14 matching lines @@
     for (const BookmarkNode* bookmark : bookmarks_for_url) {
       bookmark_model->DeleteNodeMetaInfo(bookmark,
                                          kBookmarkLastVisitDateOnMobileKey);
       bookmark_model->DeleteNodeMetaInfo(bookmark,
                                          kBookmarkLastVisitDateOnDesktopKey);
     }
   }
 }
 
 }  // namespace ntp_snippets