Rename discard to dismiss for NTP snippets and content suggestions

components/ntp_snippets/ntp_snippets_service.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/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 292 matching lines @@
 std::set<std::string> NTPSnippetsService::GetSuggestionsHosts() const {
   // |suggestions_service_| can be null in tests.
   if (!suggestions_service_)
     return std::set<std::string>();
 
   // TODO(treib): This should just call GetSnippetHostsFromPrefs.
   return GetSuggestionsHostsImpl(
       suggestions_service_->GetSuggestionsDataFromCache());
 }
 
-void NTPSnippetsService::DiscardSuggestion(const std::string& suggestion_id) {
+void NTPSnippetsService::DismissSuggestion(const std::string& suggestion_id) {
   if (!ready())
     return;
 
   std::string snippet_id = GetWithinCategoryIDFromUniqueID(suggestion_id);
 
   auto it =
       std::find_if(snippets_.begin(), snippets_.end(),
                    [&snippet_id](const std::unique_ptr<NTPSnippet>& snippet) {
                      return snippet->id() == snippet_id;
                    });
   if (it == snippets_.end())
     return;
 
-  (*it)->set_discarded(true);
+  (*it)->set_dismissed(true);
 
   database_->SaveSnippet(**it);
   database_->DeleteImage((*it)->id());
 
-  discarded_snippets_.push_back(std::move(*it));
+  dismissed_snippets_.push_back(std::move(*it));
   snippets_.erase(it);
 }
 
-void NTPSnippetsService::ClearDiscardedSuggestionsForDebugging() {
+void NTPSnippetsService::ClearDismissedSuggestionsForDebugging() {
   if (!initialized())
     return;
 
-  if (discarded_snippets_.empty())
+  if (dismissed_snippets_.empty())
     return;
 
-  database_->DeleteSnippets(discarded_snippets_);
-  discarded_snippets_.clear();
+  database_->DeleteSnippets(dismissed_snippets_);
+  dismissed_snippets_.clear();
 }
 
 void NTPSnippetsService::SetObserver(Observer* observer) {
   observer_ = observer;
 }
 
 ContentSuggestionsCategoryStatus NTPSnippetsService::GetCategoryStatus(
     ContentSuggestionsCategory category) {
   DCHECK_EQ(ContentSuggestionsCategory::ARTICLES, category);
   return category_status_;
@@ skipping 32 matching lines @@
 
   database_->SaveImage(snippet_id, image_data);
 }
 
 void NTPSnippetsService::OnDatabaseLoaded(NTPSnippet::PtrVector snippets) {
   DCHECK(state_ == State::NOT_INITED || state_ == State::SHUT_DOWN);
   if (state_ == State::SHUT_DOWN)
     return;
 
   DCHECK(snippets_.empty());
-  DCHECK(discarded_snippets_.empty());
+  DCHECK(dismissed_snippets_.empty());
   for (std::unique_ptr<NTPSnippet>& snippet : snippets) {
-    if (snippet->is_discarded())
-      discarded_snippets_.emplace_back(std::move(snippet));
+    if (snippet->is_dismissed())
+      dismissed_snippets_.emplace_back(std::move(snippet));
     else
       snippets_.emplace_back(std::move(snippet));
   }
   std::sort(snippets_.begin(), snippets_.end(),
             [](const std::unique_ptr<NTPSnippet>& lhs,
                const std::unique_ptr<NTPSnippet>& rhs) {
               return lhs->score() > rhs->score();
             });
 
   ClearExpiredSnippets();
@@ skipping 52 matching lines @@
   if (snippets_.size() > kMaxSnippetCount) {
     NTPSnippet::PtrVector to_delete(
         std::make_move_iterator(snippets_.begin() + kMaxSnippetCount),
         std::make_move_iterator(snippets_.end()));
     snippets_.resize(kMaxSnippetCount);
     database_->DeleteSnippets(to_delete);
   }
 
   UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.NumArticles",
                               snippets_.size());
-  if (snippets_.empty() && !discarded_snippets_.empty()) {
+  if (snippets_.empty() && !dismissed_snippets_.empty()) {
     UMA_HISTOGRAM_COUNTS("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded",
-                         discarded_snippets_.size());
+                         dismissed_snippets_.size());
   }
 
   NotifyNewSuggestions();
 }
 
 void NTPSnippetsService::MergeSnippets(NTPSnippet::PtrVector new_snippets) {
   DCHECK(ready());
 
-  // Remove new snippets that we already have, or that have been discarded.
+  // Remove new snippets that we already have, or that have been dismissed.
   std::set<std::string> old_snippet_ids;
-  InsertAllIDs(discarded_snippets_, &old_snippet_ids);
+  InsertAllIDs(dismissed_snippets_, &old_snippet_ids);
   InsertAllIDs(snippets_, &old_snippet_ids);
   new_snippets.erase(
       std::remove_if(
           new_snippets.begin(), new_snippets.end(),
           [&old_snippet_ids](const std::unique_ptr<NTPSnippet>& snippet) {
             if (old_snippet_ids.count(snippet->id()))
               return true;
             for (const SnippetSource& source : snippet->sources()) {
               if (old_snippet_ids.count(source.url.spec()))
                 return true;
@@ skipping 19 matching lines @@
           switches::kAddIncompleteSnippets)) {
     int num_new_snippets = new_snippets.size();
     // Remove snippets that do not have all the info we need to display it to
     // the user.
     new_snippets.erase(
         std::remove_if(new_snippets.begin(), new_snippets.end(),
                        [](const std::unique_ptr<NTPSnippet>& snippet) {
                          return !snippet->is_complete();
                        }),
         new_snippets.end());
-    int num_snippets_discarded = num_new_snippets - new_snippets.size();
+    int num_snippets_dismissed = num_new_snippets - new_snippets.size();
     UMA_HISTOGRAM_BOOLEAN("NewTabPage.Snippets.IncompleteSnippetsAfterFetch",
-                          num_snippets_discarded > 0);
-    if (num_snippets_discarded > 0) {
+                          num_snippets_dismissed > 0);
+    if (num_snippets_dismissed > 0) {
       UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.NumIncompleteSnippets",
-                                  num_snippets_discarded);
+                                  num_snippets_dismissed);
     }
   }
 
   // Save the new snippets to the DB.
   database_->SaveSnippets(new_snippets);
 
   // Insert the new snippets at the front.
   snippets_.insert(snippets_.begin(),
                    std::make_move_iterator(new_snippets.begin()),
                    std::make_move_iterator(new_snippets.end()));
@@ skipping 23 matching lines @@
   base::Time expiry = base::Time::Now();
 
   // Move expired snippets over into |to_delete|.
   NTPSnippet::PtrVector to_delete;
   for (std::unique_ptr<NTPSnippet>& snippet : snippets_) {
     if (snippet->expiry_date() <= expiry)
       to_delete.emplace_back(std::move(snippet));
   }
   Compact(&snippets_);
 
-  // Move expired discarded snippets over into |to_delete| as well.
-  for (std::unique_ptr<NTPSnippet>& snippet : discarded_snippets_) {
+  // Move expired dismissed snippets over into |to_delete| as well.
+  for (std::unique_ptr<NTPSnippet>& snippet : dismissed_snippets_) {
     if (snippet->expiry_date() <= expiry)
       to_delete.emplace_back(std::move(snippet));
   }
-  Compact(&discarded_snippets_);
+  Compact(&dismissed_snippets_);
 
   // Finally, actually delete the removed snippets from the DB.
   database_->DeleteSnippets(to_delete);
 
   // If there are any snippets left, schedule a timer for the next expiry.
-  if (snippets_.empty() && discarded_snippets_.empty())
+  if (snippets_.empty() && dismissed_snippets_.empty())
     return;
 
   base::Time next_expiry = base::Time::Max();
   for (const auto& snippet : snippets_) {
     if (snippet->expiry_date() < next_expiry)
       next_expiry = snippet->expiry_date();
   }
-  for (const auto& snippet : discarded_snippets_) {
+  for (const auto& snippet : dismissed_snippets_) {
     if (snippet->expiry_date() < next_expiry)
       next_expiry = snippet->expiry_date();
   }
   DCHECK_GT(next_expiry, expiry);
   expiry_timer_.Start(FROM_HERE, next_expiry - expiry,
                       base::Bind(&NTPSnippetsService::ClearExpiredSnippets,
                                  base::Unretained(this)));
 }
 
 void NTPSnippetsService::OnSnippetImageFetchedFromDatabase(
@@ skipping 58 matching lines @@
     suggestions_service_subscription_ =
         suggestions_service_->AddCallback(base::Bind(
             &NTPSnippetsService::OnSuggestionsChanged, base::Unretained(this)));
   }
 
   RescheduleFetching();
 }
 
 void NTPSnippetsService::EnterStateDisabled() {
   ClearCachedSuggestionsForDebugging();
-  ClearDiscardedSuggestionsForDebugging();
+  ClearDismissedSuggestionsForDebugging();
 
   expiry_timer_.Stop();
   suggestions_service_subscription_.reset();
   RescheduleFetching();
 }
 
 void NTPSnippetsService::EnterStateShutdown() {
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceShutdown());
 
@@ skipping 141 matching lines @@
 }
 
 void NTPSnippetsService::NotifyCategoryStatusChanged() {
   if (observer_) {
     observer_->OnCategoryStatusChanged(ContentSuggestionsCategory::ARTICLES,
                                        category_status_);
   }
 }
 
 }  // namespace ntp_snippets