[NTP::PhysicalWeb] In OnLost invalidate by |resolved_url|.

components/ntp_snippets/physical_web_pages/physical_web_page_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/physical_web_pages/physical_web_page_suggestions_provider.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 134 matching lines @@
                  gfx::Image::CreateFrom1xPNGBytes(
                      reinterpret_cast<const unsigned char*>(raw_data.data()),
                      raw_data.size())));
 }
 
 void PhysicalWebPageSuggestionsProvider::Fetch(
     const Category& category,
     const std::set<std::string>& known_suggestion_ids,
     const FetchDoneCallback& callback) {
   DCHECK_EQ(category, provided_category_);
+  std::vector<ContentSuggestion> suggestions =
+      GetMostRecentPhysicalWebPagesWithFilter(kMaxSuggestionsCount,
+                                              known_suggestion_ids);
+  AppendToShownScannedUrls(suggestions);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(callback, Status::Success(),
-                 base::Passed(GetMostRecentPhysicalWebPagesWithFilter(
-                     kMaxSuggestionsCount, known_suggestion_ids))));
+      FROM_HERE, base::Bind(callback, Status::Success(),
+                            base::Passed(std::move(suggestions))));
 }
 
 void PhysicalWebPageSuggestionsProvider::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
   ClearDismissedSuggestionsForDebugging(provided_category_);
 }
 
 void PhysicalWebPageSuggestionsProvider::ClearCachedSuggestions(
@@ skipping 38 matching lines @@
     CategoryStatus new_status) {
   if (category_status_ == new_status) {
     return;
   }
   category_status_ = new_status;
   observer()->OnCategoryStatusChanged(this, provided_category_, new_status);
 }
 
 void PhysicalWebPageSuggestionsProvider::FetchPhysicalWebPages() {
   DCHECK_EQ(CategoryStatus::AVAILABLE, category_status_);
+  std::vector<ContentSuggestion> suggestions =
+      GetMostRecentPhysicalWebPagesWithFilter(
+          kMaxSuggestionsCount,
+          /*excluded_ids=*/std::set<std::string>());
+  shown_resolved_urls_by_scanned_url_.clear();
+  AppendToShownScannedUrls(suggestions);
   observer()->OnNewSuggestions(this, provided_category_,
-                               GetMostRecentPhysicalWebPagesWithFilter(
-                                   kMaxSuggestionsCount,
-                                   /*excluded_ids=*/std::set<std::string>()));
+                               std::move(suggestions));
 }
 
 std::vector<ContentSuggestion>
 PhysicalWebPageSuggestionsProvider::GetMostRecentPhysicalWebPagesWithFilter(
-    int max_quantity,
+    int max_count,
     const std::set<std::string>& excluded_ids) {
   std::unique_ptr<physical_web::MetadataList> page_metadata_list =
       physical_web_data_source_->GetMetadataList();
 
   // These is to filter out dismissed suggestions and at the same time prune the
-  // dismissed IDs list removing nonavailable pages (this is need since some
+  // dismissed IDs list removing nonavailable pages (this is needed since some
   // OnLost() calls may have been missed).
   const std::set<std::string> old_dismissed_ids = ReadDismissedIDsFromPrefs();
   std::set<std::string> new_dismissed_ids;
   physical_web::MetadataList filtered_metadata_list;
   for (const auto& page_metadata : *page_metadata_list) {
     const std::string page_id = GetPageId(page_metadata);
     if (!excluded_ids.count(page_id) && !old_dismissed_ids.count(page_id)) {
       filtered_metadata_list.push_back(page_metadata);
     }
 
     if (old_dismissed_ids.count(page_id)) {
       new_dismissed_ids.insert(page_id);
     }
   }
 
   if (old_dismissed_ids.size() != new_dismissed_ids.size()) {
     StoreDismissedIDsToPrefs(new_dismissed_ids);
   }
 
   FilterOutByGroupId(filtered_metadata_list);
 
   std::sort(filtered_metadata_list.begin(), filtered_metadata_list.end(),
             CompareByDistance);
 
   std::vector<ContentSuggestion> suggestions;
   for (const auto& page_metadata : filtered_metadata_list) {
-    if (static_cast<int>(suggestions.size()) == max_quantity) {
+    if (static_cast<int>(suggestions.size()) == max_count) {
       break;
     }
     suggestions.push_back(ConvertPhysicalWebPage(page_metadata));
   }
 
   return suggestions;
 }
 
 ContentSuggestion PhysicalWebPageSuggestionsProvider::ConvertPhysicalWebPage(
     const physical_web::Metadata& page) const {
   ContentSuggestion suggestion(provided_category_, GetPageId(page),
                                page.resolved_url);
   DCHECK(base::IsStringUTF8(page.title));
   suggestion.set_title(base::UTF8ToUTF16(page.title));
   suggestion.set_publisher_name(base::UTF8ToUTF16(page.resolved_url.host()));
   DCHECK(base::IsStringUTF8(page.description));
   suggestion.set_snippet_text(base::UTF8ToUTF16(page.description));
   return suggestion;
 }
 
 // PhysicalWebListener implementation.
 void PhysicalWebPageSuggestionsProvider::OnFound(const GURL& url) {
   FetchPhysicalWebPages();
 }
 
 void PhysicalWebPageSuggestionsProvider::OnLost(const GURL& url) {
-  InvalidateSuggestion(url.spec());
+  auto it = shown_resolved_urls_by_scanned_url_.find(url);
+  if (it == shown_resolved_urls_by_scanned_url_.end()) {
+    // The notification is propagated further in case the suggestion is shown on
+    // old NTPs (created before last |shown_resolved_urls_by_scanned_url_|
+    // update).
+
+    // TODO(vitaliii): Use |resolved_url| here when it is available. Currently
+    // there is no way to find out |resolved_url|, which corresponds to this
+    // |scanned_url| (the metadata has been already removed from the Physical
+    // Web list). We use |scanned_url| (it may be the same as |resolved_url|,
+    // otherwise nothing happens), however, we should use the latter once it is
+    // provided (e.g. as an argument).
+    InvalidateSuggestion(url.spec());
+    return;
+  }
+
+  // This is not a reference, because the multimap pair will be removed below.
+  const GURL lost_resolved_url = it->second;
+  shown_resolved_urls_by_scanned_url_.erase(it);
+  if (std::find_if(shown_resolved_urls_by_scanned_url_.begin(),
+                   shown_resolved_urls_by_scanned_url_.end(),
+                   [lost_resolved_url](const std::pair<GURL, GURL>& pair) {
+                     return lost_resolved_url == pair.second;
+                   }) == shown_resolved_urls_by_scanned_url_.end()) {
+    // There are no more beacons for this URL.
+    InvalidateSuggestion(lost_resolved_url.spec());
+  }
 }
 
 void PhysicalWebPageSuggestionsProvider::OnDistanceChanged(
     const GURL& url,
     double distance_estimate) {
   FetchPhysicalWebPages();
 }
 
 void PhysicalWebPageSuggestionsProvider::InvalidateSuggestion(
     const std::string& page_id) {
   observer()->OnSuggestionInvalidated(
       this, ContentSuggestion::ID(provided_category_, page_id));
 
   // Remove |page_id| from dismissed suggestions, if present.
   std::set<std::string> dismissed_ids = ReadDismissedIDsFromPrefs();
   auto it = dismissed_ids.find(page_id);
   if (it != dismissed_ids.end()) {
     dismissed_ids.erase(it);
     StoreDismissedIDsToPrefs(dismissed_ids);
   }
 }
 
+void PhysicalWebPageSuggestionsProvider::AppendToShownScannedUrls(
+    const std::vector<ContentSuggestion>& suggestions) {
+  std::unique_ptr<physical_web::MetadataList> page_metadata_list =
+      physical_web_data_source_->GetMetadataList();
+  for (const auto& page_metadata : *page_metadata_list) {
+    if (std::find_if(suggestions.begin(), suggestions.end(),
+                     [page_metadata](const ContentSuggestion& suggestion) {
+                       return suggestion.url() == page_metadata.resolved_url;
+                     }) != suggestions.end()) {
+      shown_resolved_urls_by_scanned_url_.insert(std::make_pair(
+          page_metadata.scanned_url, page_metadata.resolved_url));
+    }
+  }
+}
+
 std::set<std::string>
 PhysicalWebPageSuggestionsProvider::ReadDismissedIDsFromPrefs() const {
   return prefs::ReadDismissedIDsFromPrefs(
       *pref_service_, prefs::kDismissedPhysicalWebPageSuggestions);
 }
 
 void PhysicalWebPageSuggestionsProvider::StoreDismissedIDsToPrefs(
     const std::set<std::string>& dismissed_ids) {
   prefs::StoreDismissedIDsToPrefs(pref_service_,
                                   prefs::kDismissedPhysicalWebPageSuggestions,
                                   dismissed_ids);
 }
 
 }  // namespace ntp_snippets