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

components/ntp_snippets/remote/remote_suggestions_provider.cc

 // Copyright 2015 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/remote/remote_suggestions_provider.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 83 matching lines @@
       value_hours = kDefaultFetchingIntervalActiveSuggestionsConsumer[index];
       param_name = kFetchingIntervalParamNameActiveSuggestionsConsumer[index];
       break;
   }
 
   // The default value can be overridden by a variation parameter.
   std::string param_value_str = variations::GetVariationParamValueByFeature(
       ntp_snippets::kArticleSuggestionsFeature, param_name);
   if (!param_value_str.empty()) {
     double param_value_hours = 0.0;
-    if (base::StringToDouble(param_value_str, &param_value_hours))
+    if (base::StringToDouble(param_value_str, &param_value_hours)) {
       value_hours = param_value_hours;
-    else
+    } else {
       LOG(WARNING) << "Invalid value for variation parameter " << param_name;
+    }
   }
 
   return base::TimeDelta::FromSecondsD(value_hours * 3600.0);
 }
 
 std::unique_ptr<std::vector<std::string>> GetSnippetIDVector(
     const NTPSnippet::PtrVector& snippets) {
   auto result = base::MakeUnique<std::vector<std::string>>();
   for (const auto& snippet : snippets) {
     result->push_back(snippet->id());
   }
   return result;
 }
 
 bool HasIntersection(const std::vector<std::string>& a,
                      const std::set<std::string>& b) {
   for (const std::string& item : a) {
-    if (base::ContainsValue(b, item))
+    if (base::ContainsValue(b, item)) {
       return true;
+    }
   }
   return false;
 }
 
 void EraseByPrimaryID(NTPSnippet::PtrVector* snippets,
                       const std::vector<std::string>& ids) {
   std::set<std::string> ids_lookup(ids.begin(), ids.end());
   snippets->erase(
       std::remove_if(snippets->begin(), snippets->end(),
                      [&ids_lookup](const std::unique_ptr<NTPSnippet>& snippet) {
@@ skipping 21 matching lines @@
 void RemoveNullPointers(NTPSnippet::PtrVector* snippets) {
   snippets->erase(
       std::remove_if(
           snippets->begin(), snippets->end(),
           [](const std::unique_ptr<NTPSnippet>& snippet) { return !snippet; }),
       snippets->end());
 }
 
 void AssignExpiryAndPublishDates(NTPSnippet::PtrVector* snippets) {
   for (std::unique_ptr<NTPSnippet>& snippet : *snippets) {
-    if (snippet->publish_date().is_null())
+    if (snippet->publish_date().is_null()) {
       snippet->set_publish_date(base::Time::Now());
+    }
     if (snippet->expiry_date().is_null()) {
       snippet->set_expiry_date(
           snippet->publish_date() +
           base::TimeDelta::FromMinutes(kDefaultExpiryTimeMins));
     }
   }
 }
 
 void RemoveIncompleteSnippets(NTPSnippet::PtrVector* snippets) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 20 matching lines @@
 
 std::vector<ContentSuggestion> ConvertToContentSuggestions(
     Category category,
     const NTPSnippet::PtrVector& snippets) {
   std::vector<ContentSuggestion> result;
   for (const std::unique_ptr<NTPSnippet>& snippet : snippets) {
     // TODO(sfiera): if a snippet is not going to be displayed, move it
     // directly to content.dismissed on fetch. Otherwise, we might prune
     // other snippets to get down to kMaxSnippetCount, only to hide one of the
     // incomplete ones we kept.
-    if (!snippet->is_complete())
+    if (!snippet->is_complete()) {
       continue;
+    }
     ContentSuggestion suggestion(category, snippet->id(),
                                  snippet->best_source().url);
     suggestion.set_amp_url(snippet->best_source().amp_url);
     suggestion.set_title(base::UTF8ToUTF16(snippet->title()));
     suggestion.set_snippet_text(base::UTF8ToUTF16(snippet->snippet()));
     suggestion.set_publish_date(snippet->publish_date());
     suggestion.set_publisher_name(
         base::UTF8ToUTF16(snippet->best_source().publisher_name));
     suggestion.set_score(snippet->score());
     result.emplace_back(std::move(suggestion));
   }
   return result;
 }
 
 void CallWithEmptyResults(FetchDoneCallback callback, Status status) {
-  if (callback.is_null())
+  if (callback.is_null()) {
     return;
+  }
   callback.Run(status, std::vector<ContentSuggestion>());
 }
 
 }  // namespace
 
 RemoteSuggestionsProvider::RemoteSuggestionsProvider(
     Observer* observer,
     CategoryFactory* category_factory,
     PrefService* pref_service,
     const std::string& application_language_code,
@@ skipping 60 matching lines @@
   registry->RegisterListPref(kDeprecatedSnippetHostsPref);
   registry->RegisterListPref(prefs::kRemoteSuggestionCategories);
   registry->RegisterInt64Pref(prefs::kSnippetBackgroundFetchingIntervalWifi, 0);
   registry->RegisterInt64Pref(prefs::kSnippetBackgroundFetchingIntervalFallback,
                               0);
 
   NTPSnippetsStatusService::RegisterProfilePrefs(registry);
 }
 
 void RemoteSuggestionsProvider::FetchSnippets(bool interactive_request) {
-  if (ready())
+  if (ready()) {
     FetchSnippetsFromHosts(std::set<std::string>(), interactive_request);
-  else
+  } else {
     fetch_when_ready_ = true;
+  }
 }
 
 void RemoteSuggestionsProvider::FetchSnippetsFromHosts(
     const std::set<std::string>& hosts,
     bool interactive_request) {
   // TODO(tschumann): FetchSnippets() and FetchSnippetsFromHost() implement the
   // fetch logic when called by the background fetcher or interactive "reload"
   // requests. Fetch() is right now only called for the fetch-more use case.
   // The names are confusing and we need to clean them up.
-  if (!ready())
+  if (!ready()) {
     return;
+  }
   MarkEmptyCategoriesAsLoading();
 
   NTPSnippetsFetcher::Params params =
       BuildFetchParams(/*exclude_archived_suggestions=*/true);
   params.hosts = hosts;
   params.interactive_request = interactive_request;
   snippets_fetcher_->FetchSnippets(
       params, base::BindOnce(&RemoteSuggestionsProvider::OnFetchFinished,
                              base::Unretained(this)));
 }
@@ skipping 40 matching lines @@
       }
     }
   }
   return result;
 }
 
 void RemoteSuggestionsProvider::MarkEmptyCategoriesAsLoading() {
   for (const auto& item : category_contents_) {
     Category category = item.first;
     const CategoryContent& content = item.second;
-    if (content.snippets.empty())
+    if (content.snippets.empty()) {
       UpdateCategoryStatus(category, CategoryStatus::AVAILABLE_LOADING);
+    }
   }
 }
 
 void RemoteSuggestionsProvider::RescheduleFetching(bool force) {
   // The scheduler only exists on Android so far, it's null on other platforms.
-  if (!scheduler_)
+  if (!scheduler_) {
     return;
+  }
 
   if (ready()) {
     base::TimeDelta old_interval_wifi = base::TimeDelta::FromInternalValue(
         pref_service_->GetInt64(prefs::kSnippetBackgroundFetchingIntervalWifi));
     base::TimeDelta old_interval_fallback =
         base::TimeDelta::FromInternalValue(pref_service_->GetInt64(
             prefs::kSnippetBackgroundFetchingIntervalFallback));
     UserClassifier::UserClass user_class = user_classifier_->GetUserClass();
     base::TimeDelta interval_wifi =
         GetFetchingInterval(/*is_wifi=*/true, user_class);
@@ skipping 28 matching lines @@
 }
 
 CategoryInfo RemoteSuggestionsProvider::GetCategoryInfo(Category category) {
   auto content_it = category_contents_.find(category);
   DCHECK(content_it != category_contents_.end());
   return content_it->second.info;
 }
 
 void RemoteSuggestionsProvider::DismissSuggestion(
     const ContentSuggestion::ID& suggestion_id) {
-  if (!ready())
+  if (!ready()) {
     return;
+  }
 
   auto content_it = category_contents_.find(suggestion_id.category());
   DCHECK(content_it != category_contents_.end());
   CategoryContent* content = &content_it->second;
   DismissSuggestionFromCategoryContent(content,
                                        suggestion_id.id_within_category());
 }
 
 void RemoteSuggestionsProvider::FetchSuggestionImage(
     const ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
   database_->LoadImage(
       suggestion_id.id_within_category(),
       base::Bind(&RemoteSuggestionsProvider::OnSnippetImageFetchedFromDatabase,
                  base::Unretained(this), callback, suggestion_id));
 }
 
 void RemoteSuggestionsProvider::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
   // Both time range and the filter are ignored and all suggestions are removed,
   // because it is not known which history entries were used for the suggestions
   // personalization.
-  if (!ready())
+  if (!ready()) {
     nuke_when_initialized_ = true;
-  else
+  } else {
     NukeAllSnippets();
+  }
 }
 
 void RemoteSuggestionsProvider::ClearCachedSuggestions(Category category) {
-  if (!initialized())
+  if (!initialized()) {
     return;
+  }
 
   auto content_it = category_contents_.find(category);
   if (content_it == category_contents_.end()) {
     return;
   }
   CategoryContent* content = &content_it->second;
-  if (content->snippets.empty())
+  if (content->snippets.empty()) {
     return;
+  }
 
   database_->DeleteSnippets(GetSnippetIDVector(content->snippets));
   database_->DeleteImages(GetSnippetIDVector(content->snippets));
   content->snippets.clear();
 
-  if (IsCategoryStatusAvailable(content->status))
+  if (IsCategoryStatusAvailable(content->status)) {
     NotifyNewSuggestions(category, *content);
+  }
 }
 
 void RemoteSuggestionsProvider::GetDismissedSuggestionsForDebugging(
     Category category,
     const DismissedSuggestionsCallback& callback) {
   auto content_it = category_contents_.find(category);
   DCHECK(content_it != category_contents_.end());
   callback.Run(
       ConvertToContentSuggestions(category, content_it->second.dismissed));
 }
 
 void RemoteSuggestionsProvider::ClearDismissedSuggestionsForDebugging(
     Category category) {
   auto content_it = category_contents_.find(category);
   DCHECK(content_it != category_contents_.end());
   CategoryContent* content = &content_it->second;
 
-  if (!initialized())
+  if (!initialized()) {
     return;
+  }
 
-  if (content->dismissed.empty())
+  if (content->dismissed.empty()) {
     return;
+  }
 
   database_->DeleteSnippets(GetSnippetIDVector(content->dismissed));
   // The image got already deleted when the suggestion was dismissed.
 
   content->dismissed.clear();
 }
 
 // static
 int RemoteSuggestionsProvider::GetMaxSnippetCountForTesting() {
   return kMaxSnippetCount;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Private methods
 
 GURL RemoteSuggestionsProvider::FindSnippetImageUrl(
     const ContentSuggestion::ID& suggestion_id) const {
   DCHECK(base::ContainsKey(category_contents_, suggestion_id.category()));
 
   const CategoryContent& content =
       category_contents_.at(suggestion_id.category());
   const NTPSnippet* snippet =
       content.FindSnippet(suggestion_id.id_within_category());
-  if (!snippet)
+  if (!snippet) {
     return GURL();
+  }
   return snippet->salient_image_url();
 }
 
 // image_fetcher::ImageFetcherDelegate implementation.
 void RemoteSuggestionsProvider::OnImageDataFetched(
     const std::string& id_within_category,
     const std::string& image_data) {
-  if (image_data.empty())
+  if (image_data.empty()) {
     return;
+  }
 
   // Only save the image if the corresponding snippet still exists.
   bool found = false;
   for (const auto& entry : category_contents_) {
     if (entry.second.FindSnippet(id_within_category)) {
       found = true;
       break;
     }
   }
-  if (!found)
+  if (!found) {
     return;
+  }
 
   // Only cache the data in the DB, the actual serving is done in the callback
   // provided to |image_fetcher_| (OnSnippetImageDecodedFromNetwork()).
   database_->SaveImage(id_within_category, image_data);
 }
 
 void RemoteSuggestionsProvider::OnDatabaseLoaded(
     NTPSnippet::PtrVector snippets) {
-  if (state_ == State::ERROR_OCCURRED)
+  if (state_ == State::ERROR_OCCURRED) {
     return;
+  }
   DCHECK(state_ == State::NOT_INITED);
   DCHECK(base::ContainsKey(category_contents_, articles_category_));
 
   base::TimeDelta database_load_time =
       base::TimeTicks::Now() - database_load_start_;
   UMA_HISTOGRAM_MEDIUM_TIMES("NewTabPage.Snippets.DatabaseLoadTime",
                              database_load_time);
 
   NTPSnippet::PtrVector to_delete;
   for (std::unique_ptr<NTPSnippet>& snippet : snippets) {
     Category snippet_category =
         category_factory()->FromRemoteCategory(snippet->remote_category_id());
     auto content_it = category_contents_.find(snippet_category);
     // We should already know about the category.
     if (content_it == category_contents_.end()) {
       DLOG(WARNING) << "Loaded a suggestion for unknown category "
                     << snippet_category << " from the DB; deleting";
       to_delete.emplace_back(std::move(snippet));
       continue;
     }
     CategoryContent* content = &content_it->second;
-    if (snippet->is_dismissed())
+    if (snippet->is_dismissed()) {
       content->dismissed.emplace_back(std::move(snippet));
-    else
+    } else {
       content->snippets.emplace_back(std::move(snippet));
+    }
   }
   if (!to_delete.empty()) {
     database_->DeleteSnippets(GetSnippetIDVector(to_delete));
     database_->DeleteImages(GetSnippetIDVector(to_delete));
   }
 
   // Sort the suggestions in each category.
   // TODO(treib): Persist the actual order in the DB somehow? crbug.com/654409
   for (auto& entry : category_contents_) {
     CategoryContent* content = &entry.second;
@@ skipping 143 matching lines @@
                               content.snippets.size());
   if (content.snippets.empty() && !content.dismissed.empty()) {
     UMA_HISTOGRAM_COUNTS("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded",
                          content.dismissed.size());
   }
 
   // Reschedule after a successful fetch. This resets all currently scheduled
   // fetches, to make sure the fallback interval triggers only if no wifi fetch
   // succeeded, and also that we don't do a background fetch immediately after
   // a user-initiated one.
-  if (fetched_categories)
+  if (fetched_categories) {
     RescheduleFetching(true);
+  }
 }
 
 void RemoteSuggestionsProvider::ArchiveSnippets(
     CategoryContent* content,
     NTPSnippet::PtrVector* to_archive) {
   // Archive previous snippets - move them at the beginning of the list.
   content->archived.insert(content->archived.begin(),
                            std::make_move_iterator(to_archive->begin()),
                            std::make_move_iterator(to_archive->end()));
   to_archive->clear();
@@ skipping 21 matching lines @@
 
 void RemoteSuggestionsProvider::IntegrateSnippets(
     CategoryContent* content,
     NTPSnippet::PtrVector new_snippets) {
   DCHECK(ready());
 
   // Do not touch the current set of snippets if the newly fetched one is empty.
   // TODO(tschumann): This should go. If we get empty results we should update
   // accordingly and remove the old one (only of course if this was not received
   // through a fetch-more).
-  if (new_snippets.empty())
+  if (new_snippets.empty()) {
     return;
+  }
 
   // It's entirely possible that the newly fetched snippets contain articles
   // that have been present before.
   // We need to make sure to only delete and archive snippets that don't
   // appear with the same ID in the new suggestions (it's fine for additional
   // IDs though).
   EraseByPrimaryID(&content->snippets, *GetSnippetIDVector(new_snippets));
   // Do not delete the thumbnail images as they are still handy on open NTPs.
   database_->DeleteSnippets(GetSnippetIDVector(content->snippets));
   // Note, that ArchiveSnippets will clear |content->snippets|.
   ArchiveSnippets(content, &content->snippets);
 
   database_->SaveSnippets(new_snippets);
 
   content->snippets = std::move(new_snippets);
 }
 
 void RemoteSuggestionsProvider::DismissSuggestionFromCategoryContent(
     CategoryContent* content,
     const std::string& id_within_category) {
   auto it = std::find_if(
       content->snippets.begin(), content->snippets.end(),
       [&id_within_category](const std::unique_ptr<NTPSnippet>& snippet) {
         return snippet->id() == id_within_category;
       });
-  if (it == content->snippets.end())
+  if (it == content->snippets.end()) {
     return;
+  }
 
   (*it)->set_dismissed(true);
 
   database_->SaveSnippet(**it);
 
   content->dismissed.push_back(std::move(*it));
   content->snippets.erase(it);
 }
 
 void RemoteSuggestionsProvider::ClearExpiredDismissedSnippets() {
   std::vector<Category> categories_to_erase;
 
   const base::Time now = base::Time::Now();
 
   for (auto& item : category_contents_) {
     Category category = item.first;
     CategoryContent* content = &item.second;
 
     NTPSnippet::PtrVector to_delete;
     // Move expired dismissed snippets over into |to_delete|.
     for (std::unique_ptr<NTPSnippet>& snippet : content->dismissed) {
-      if (snippet->expiry_date() <= now)
+      if (snippet->expiry_date() <= now) {
         to_delete.emplace_back(std::move(snippet));
+      }
     }
     RemoveNullPointers(&content->dismissed);
 
     // Delete the images.
     database_->DeleteImages(GetSnippetIDVector(to_delete));
     // Delete the removed article suggestions from the DB.
     database_->DeleteSnippets(GetSnippetIDVector(to_delete));
 
     if (content->snippets.empty() && content->dismissed.empty() &&
         category != articles_category_ &&
@@ skipping 31 matching lines @@
   // not be personalized.
   for (const auto& item : category_contents_) {
     Category category = item.first;
 
     ClearCachedSuggestions(category);
     ClearDismissedSuggestionsForDebugging(category);
 
     UpdateCategoryStatus(category, CategoryStatus::NOT_PROVIDED);
 
     // Remove the category entirely; it may or may not reappear.
-    if (category != articles_category_)
+    if (category != articles_category_) {
       categories_to_erase.push_back(category);
+    }
   }
 
   for (Category category : categories_to_erase) {
     category_contents_.erase(category);
   }
 
   StoreCategoriesToPrefs();
 }
 
 void RemoteSuggestionsProvider::OnSnippetImageFetchedFromDatabase(
@@ skipping 80 matching lines @@
     // network request.
     FetchSnippets(/*interactive_request=*/false);
     fetch_when_ready_ = false;
   }
 
   for (const auto& item : category_contents_) {
     Category category = item.first;
     const CategoryContent& content = item.second;
     // FetchSnippets has set the status to |AVAILABLE_LOADING| if relevant,
     // otherwise we transition to |AVAILABLE| here.
-    if (content.status != CategoryStatus::AVAILABLE_LOADING)
+    if (content.status != CategoryStatus::AVAILABLE_LOADING) {
       UpdateCategoryStatus(category, CategoryStatus::AVAILABLE);
+    }
   }
 }
 
 void RemoteSuggestionsProvider::EnterStateDisabled() {
   NukeAllSnippets();
 }
 
 void RemoteSuggestionsProvider::EnterStateError() {
   snippets_status_service_.reset();
 }
@@ skipping 19 matching lines @@
       base::Bind(&RemoteSuggestionsProvider::OnSnippetsStatusChanged,
                  base::Unretained(this)));
 
   // Always notify here even if we got nothing from the database, because we
   // don't know how long the fetch will take or if it will even complete.
   for (const auto& item : category_contents_) {
     Category category = item.first;
     const CategoryContent& content = item.second;
     // Note: We might be in a non-available status here, e.g. DISABLED due to
     // enterprise policy.
-    if (IsCategoryStatusAvailable(content.status))
+    if (IsCategoryStatusAvailable(content.status)) {
       NotifyNewSuggestions(category, content);
+    }
   }
 }
 
 void RemoteSuggestionsProvider::OnSnippetsStatusChanged(
     SnippetsStatus old_snippets_status,
     SnippetsStatus new_snippets_status) {
   switch (new_snippets_status) {
     case SnippetsStatus::ENABLED_AND_SIGNED_IN:
       if (old_snippets_status == SnippetsStatus::ENABLED_AND_SIGNED_OUT) {
         DCHECK(state_ == State::READY);
@@ skipping 26 matching lines @@
       break;
 
     case SnippetsStatus::SIGNED_OUT_AND_DISABLED:
       EnterState(State::DISABLED);
       UpdateAllCategoryStatus(CategoryStatus::SIGNED_OUT);
       break;
   }
 }
 
 void RemoteSuggestionsProvider::EnterState(State state) {
-  if (state == state_)
+  if (state == state_) {
     return;
+  }
 
   UMA_HISTOGRAM_ENUMERATION("NewTabPage.Snippets.EnteredState",
                             static_cast<int>(state),
                             static_cast<int>(State::COUNT));
 
   switch (state) {
     case State::NOT_INITED:
       // Initial state, it should not be possible to get back there.
       NOTREACHED();
       break;
@@ skipping 41 matching lines @@
            << " items in category " << category;
   observer()->OnNewSuggestions(this, category, std::move(result));
 }
 
 void RemoteSuggestionsProvider::UpdateCategoryStatus(Category category,
                                                      CategoryStatus status) {
   auto content_it = category_contents_.find(category);
   DCHECK(content_it != category_contents_.end());
   CategoryContent& content = content_it->second;
 
-  if (status == content.status)
+  if (status == content.status) {
     return;
+  }
 
   DVLOG(1) << "UpdateCategoryStatus(): " << category.id() << ": "
            << static_cast<int>(content.status) << " -> "
            << static_cast<int>(status);
   content.status = status;
   observer()->OnCategoryStatusChanged(this, category, content.status);
 }
 
 void RemoteSuggestionsProvider::UpdateAllCategoryStatus(CategoryStatus status) {
   for (const auto& category : category_contents_) {
@@ skipping 95 matching lines @@
             : BuildRemoteCategoryInfo(title, allow_fetching_more_results);
     CategoryContent* content = UpdateCategoryInfo(category, info);
     content->included_in_last_server_response =
         included_in_last_server_response;
   }
 }
 
 void RemoteSuggestionsProvider::StoreCategoriesToPrefs() {
   // Collect all the CategoryContents.
   std::vector<std::pair<Category, const CategoryContent*>> to_store;
-  for (const auto& entry : category_contents_)
+  for (const auto& entry : category_contents_) {
     to_store.emplace_back(entry.first, &entry.second);
+  }
   // Sort them into the proper category order.
   std::sort(to_store.begin(), to_store.end(),
             [this](const std::pair<Category, const CategoryContent*>& left,
                    const std::pair<Category, const CategoryContent*>& right) {
               return category_factory()->CompareCategories(left.first,
                                                            right.first);
             });
   // Convert the relevant info into a base::ListValue for storage.
   base::ListValue list;
   for (const auto& entry : to_store) {
@@ skipping 20 matching lines @@
 RemoteSuggestionsProvider::CategoryContent::CategoryContent(CategoryContent&&) =
     default;
 
 RemoteSuggestionsProvider::CategoryContent::~CategoryContent() = default;
 
 RemoteSuggestionsProvider::CategoryContent&
 RemoteSuggestionsProvider::CategoryContent::operator=(CategoryContent&&) =
     default;
 
 }  // namespace ntp_snippets