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

components/ntp_snippets/offline_pages/recent_tab_suggestions_provider.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/offline_pages/recent_tab_suggestions_provider.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 56 matching lines @@
   offline_page_model_->AddObserver(this);
   FetchRecentTabs();
 }
 
 RecentTabSuggestionsProvider::~RecentTabSuggestionsProvider() {
   offline_page_model_->RemoveObserver(this);
 }
 
 CategoryStatus RecentTabSuggestionsProvider::GetCategoryStatus(
     Category category) {
-  if (category == provided_category_)
+  if (category == provided_category_) {
     return category_status_;
+  }
   NOTREACHED() << "Unknown category " << category.id();
   return CategoryStatus::NOT_PROVIDED;
 }
 
 CategoryInfo RecentTabSuggestionsProvider::GetCategoryInfo(Category category) {
   DCHECK_EQ(provided_category_, category);
   return CategoryInfo(
       l10n_util::GetStringUTF16(IDS_NTP_RECENT_TAB_SUGGESTIONS_SECTION_HEADER),
       ContentSuggestionsCardLayout::MINIMAL_CARD,
       /*has_more_action=*/false,
@@ skipping 77 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Private methods
 
 void RecentTabSuggestionsProvider::
     GetPagesMatchingQueryCallbackForGetDismissedSuggestions(
         const DismissedSuggestionsCallback& callback,
         const std::vector<OfflinePageItem>& offline_pages) const {
   std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs();
   std::vector<ContentSuggestion> suggestions;
   for (const OfflinePageItem& item : offline_pages) {
-    if (!dismissed_ids.count(base::IntToString(item.offline_id)))
+    if (!dismissed_ids.count(base::IntToString(item.offline_id))) {
       continue;
+    }
 
     suggestions.push_back(ConvertOfflinePage(item));
   }
   callback.Run(std::move(suggestions));
 }
 
 void RecentTabSuggestionsProvider::OfflinePageModelLoaded(
     offline_pages::OfflinePageModel* model) {}
 
 void RecentTabSuggestionsProvider::OfflinePageModelChanged(
     offline_pages::OfflinePageModel* model) {
   DCHECK_EQ(offline_page_model_, model);
   FetchRecentTabs();
 }
 
 void RecentTabSuggestionsProvider::
     GetPagesMatchingQueryCallbackForFetchRecentTabs(
         const std::vector<OfflinePageItem>& offline_pages) {
   NotifyStatusChanged(CategoryStatus::AVAILABLE);
   std::set<std::string> old_dismissed_ids = ReadDismissedIDsFromPrefs();
   std::set<std::string> new_dismissed_ids;
   std::vector<const OfflinePageItem*> recent_tab_items;
   for (const OfflinePageItem& item : offline_pages) {
     std::string offline_page_id = base::IntToString(item.offline_id);
-    if (old_dismissed_ids.count(offline_page_id))
+    if (old_dismissed_ids.count(offline_page_id)) {
       new_dismissed_ids.insert(offline_page_id);
-    else
+    } else {
       recent_tab_items.push_back(&item);
+    }
   }
 
   observer()->OnNewSuggestions(
       this, provided_category_,
       GetMostRecentlyVisited(std::move(recent_tab_items)));
-  if (new_dismissed_ids.size() != old_dismissed_ids.size())
+  if (new_dismissed_ids.size() != old_dismissed_ids.size()) {
     StoreDismissedIDsToPrefs(new_dismissed_ids);
+  }
 }
 
 void RecentTabSuggestionsProvider::OfflinePageDeleted(
     int64_t offline_id,
     const ClientId& client_id) {
   // Because we never switch to NOT_PROVIDED dynamically, there can be no open
   // UI containing an invalidated suggestion unless the status is something
   // other than NOT_PROVIDED, so only notify invalidation in that case.
-  if (category_status_ != CategoryStatus::NOT_PROVIDED)
+  if (category_status_ != CategoryStatus::NOT_PROVIDED) {
     InvalidateSuggestion(offline_id);
+  }
 }
 
 void RecentTabSuggestionsProvider::FetchRecentTabs() {
   offline_page_model_->GetPagesMatchingQuery(
       BuildRecentTabsQuery(offline_page_model_),
       base::Bind(&RecentTabSuggestionsProvider::
                      GetPagesMatchingQueryCallbackForFetchRecentTabs,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RecentTabSuggestionsProvider::NotifyStatusChanged(
     CategoryStatus new_status) {
   DCHECK_NE(CategoryStatus::NOT_PROVIDED, category_status_);
-  if (category_status_ == new_status)
+  if (category_status_ == new_status) {
     return;
+  }
   category_status_ = new_status;
   observer()->OnCategoryStatusChanged(this, provided_category_, new_status);
 }
 
 ContentSuggestion RecentTabSuggestionsProvider::ConvertOfflinePage(
     const OfflinePageItem& offline_page) const {
   // TODO(vitaliii): Make sure the URL is opened in the existing tab.
   ContentSuggestion suggestion(provided_category_,
                                base::IntToString(offline_page.offline_id),
                                offline_page.url);
@@ skipping 15 matching lines @@
 }
 
 std::vector<ContentSuggestion>
 RecentTabSuggestionsProvider::GetMostRecentlyVisited(
     std::vector<const OfflinePageItem*> offline_page_items) const {
   std::sort(offline_page_items.begin(), offline_page_items.end(),
             OrderOfflinePagesByMostRecentlyVisitedFirst());
   std::vector<ContentSuggestion> suggestions;
   for (const OfflinePageItem* offline_page_item : offline_page_items) {
     suggestions.push_back(ConvertOfflinePage(*offline_page_item));
-    if (suggestions.size() == kMaxSuggestionsCount)
+    if (suggestions.size() == kMaxSuggestionsCount) {
       break;
+    }
   }
   return suggestions;
 }
 
 void RecentTabSuggestionsProvider::InvalidateSuggestion(int64_t offline_id) {
   std::string offline_page_id = base::IntToString(offline_id);
   observer()->OnSuggestionInvalidated(
       this, ContentSuggestion::ID(provided_category_, offline_page_id));
 
   std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs();
@@ skipping 11 matching lines @@
 }
 
 void RecentTabSuggestionsProvider::StoreDismissedIDsToPrefs(
     const std::set<std::string>& dismissed_ids) {
   prefs::StoreDismissedIDsToPrefs(pref_service_,
                                   prefs::kDismissedRecentOfflineTabSuggestions,
                                   dismissed_ids);
 }
 
 }  // namespace ntp_snippets