Inform server of dismissed articles.

components/ntp_snippets/ntp_snippets_fetcher.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/ntp_snippets_fetcher.h"
 
 #include <stdlib.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 52 matching lines @@
 
 // Constants for possible values of the "fetching_personalization" parameter.
 const char kPersonalizationPersonalString[] = "personal";
 const char kPersonalizationNonPersonalString[] = "non_personal";
 const char kPersonalizationBothString[] = "both";  // the default value
 
 // Constants for possible values of the "fetching_host_restrict" parameter.
 const char kHostRestrictionOnString[] = "on";  // the default value
 const char kHostRestrictionOffString[] = "off";
 
+const int kMaxExcludedIds = 100;
+
 std::string FetchResultToString(NTPSnippetsFetcher::FetchResult result) {
   switch (result) {
     case NTPSnippetsFetcher::FetchResult::SUCCESS:
       return "OK";
     case NTPSnippetsFetcher::FetchResult::EMPTY_HOSTS:
       return "Cannot fetch for empty hosts list.";
     case NTPSnippetsFetcher::FetchResult::URL_REQUEST_STATUS_ERROR:
       return "URLRequestStatus error";
     case NTPSnippetsFetcher::FetchResult::HTTP_ERROR:
       return "HTTP error";
@@ skipping 126 matching lines @@
 }
 
 void NTPSnippetsFetcher::SetCallback(
     const SnippetsAvailableCallback& callback) {
   snippets_available_callback_ = callback;
 }
 
 void NTPSnippetsFetcher::FetchSnippetsFromHosts(
     const std::set<std::string>& hosts,
     const std::string& language_code,
+    const std::set<std::string>& excluded_ids,
     int count,
     bool interactive_request) {
   if (!request_throttler_.DemandQuotaForRequest(interactive_request))
     return;
 
   hosts_ = hosts;
   fetch_start_time_ = tick_clock_->NowTicks();
+  excluded_ids_ = excluded_ids;
 
   if (UsesHostRestrictions() && hosts_.empty()) {
     FetchFinished(OptionalSnippets(), FetchResult::EMPTY_HOSTS,
                   /*extra_message=*/std::string());
     return;
   }
 
   locale_ = PosixLocaleFromBCP47Language(language_code);
   count_to_fetch_ = count;
 
@@ skipping 74 matching lines @@
       if (!user_locale.empty()) {
         request->SetString("user_locale", user_locale);
       }
       break;
     }
 
     case CHROME_CONTENT_SUGGESTIONS_API: {
       if (!user_locale.empty()) {
         request->SetString("uiLanguage", user_locale);
       }
+
       auto regular_hosts = base::MakeUnique<base::ListValue>();
       for (const auto& host : host_restricts) {
         regular_hosts->AppendString(host);
       }
       request->Set("regularlyVisitedHostNames", std::move(regular_hosts));
 
+      auto excluded = base::MakeUnique<base::ListValue>();
+      for (const auto& id : excluded_ids) {
+        excluded->AppendString(id);
+        if (excluded->GetSize() >= kMaxExcludedIds)
+          break;
+      }
+      request->Set("excludedSuggestionIds", std::move(excluded));
+
       // TODO(sfiera): support authentication and personalization
       // TODO(sfiera): support count_to_fetch
       break;
     }
   }
 
   std::string request_json;
   bool success = base::JSONWriter::WriteWithOptions(
       *request, base::JSONWriter::OPTIONS_PRETTY_PRINT, &request_json);
   DCHECK(success);
@@ skipping 49 matching lines @@
   const std::string& key = is_stable_channel_
                                ? google_apis::GetAPIKey()
                                : google_apis::GetNonStableAPIKey();
   GURL url(base::StringPrintf(kSnippetsServerNonAuthorizedFormat,
                               fetch_url_.spec().c_str(), key.c_str()));
 
   RequestParams params;
   params.fetch_api = fetch_api_;
   params.host_restricts =
       UsesHostRestrictions() ? hosts_ : std::set<std::string>();
+  params.excluded_ids = excluded_ids_;
   params.count_to_fetch = count_to_fetch_;
   FetchSnippetsImpl(url, std::string(), params.BuildRequest());
 }
 
 void NTPSnippetsFetcher::FetchSnippetsAuthenticated(
     const std::string& account_id,
     const std::string& oauth_access_token) {
   RequestParams params;
   params.fetch_api = fetch_api_;
   params.obfuscated_gaia_id = account_id;
   params.only_return_personalized_results =
       personalization_ == Personalization::kPersonal;
   params.user_locale = locale_;
   params.host_restricts =
       UsesHostRestrictions() ? hosts_ : std::set<std::string>();
+  params.excluded_ids = excluded_ids_;
   params.count_to_fetch = count_to_fetch_;
   // TODO(jkrcal, treib): Add unit-tests for authenticated fetches.
   FetchSnippetsImpl(fetch_url_,
                     base::StringPrintf(kAuthorizationRequestHeaderFormat,
                                        oauth_access_token.c_str()),
                     params.BuildRequest());
 }
 
 void NTPSnippetsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
@@ skipping 178 matching lines @@
   }
   UMA_HISTOGRAM_ENUMERATION("NewTabPage.Snippets.FetchResult",
                             static_cast<int>(result),
                             static_cast<int>(FetchResult::RESULT_MAX));
 
   if (!snippets_available_callback_.is_null())
     snippets_available_callback_.Run(std::move(snippets));
 }
 
 }  // namespace ntp_snippets