Removes a data-dependent DCHECK().

components/ntp_snippets/remote/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/remote/ntp_snippets_fetcher.h"
 
 #include <cstdlib>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 126 matching lines @@
   return true;
 }
 
 // Creates snippets from dictionary values in |list| and adds them to
 // |snippets|. Returns true on success, false if anything went wrong.
 bool AddSnippetsFromListValue(bool content_suggestions_api,
                               const base::ListValue& list,
                               NTPSnippet::PtrVector* snippets) {
   for (const auto& value : list) {
     const base::DictionaryValue* dict = nullptr;
-    if (!value->GetAsDictionary(&dict))
+    if (!value->GetAsDictionary(&dict)) {

[Marc Treib, 2016/10/06 15:36:13]

Ah, a fan of braces for single-line bodies... I'm still waiting for the epic
fight against Bernhard :D

[tschumann, 2016/10/06 17:57:42]

added those after adding debug statements and wondered why the test changed ;-)
Yes, this is on my todo list :-)

       return false;
+    }
 
     std::unique_ptr<NTPSnippet> snippet;
     if (content_suggestions_api) {
       snippet = NTPSnippet::CreateFromContentSuggestionsDictionary(*dict);
     } else {
       snippet = NTPSnippet::CreateFromChromeReaderDictionary(*dict);
     }
-    if (!snippet)
+    if (!snippet) {
       return false;
+    }
 
     snippets->push_back(std::move(snippet));
   }
   return true;
 }
 
 // Translate the BCP 47 |language_code| into a posix locale string.
 std::string PosixLocaleFromBCP47Language(const std::string& language_code) {
   char locale[ULOC_FULLNAME_CAPACITY];
   UErrorCode error = U_ZERO_ERROR;
@@ skipping 82 matching lines @@
   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)) {
-    FetchFinished(OptionalSnippets(),
+    FetchFinished(OptionalFetchedCategories(),
                   interactive_request
                       ? FetchResult::INTERACTIVE_QUOTA_ERROR
                       : FetchResult::NON_INTERACTIVE_QUOTA_ERROR,
                   /*extra_message=*/std::string());
     return;
   }
 
   hosts_ = hosts;
   fetch_start_time_ = tick_clock_->NowTicks();
   excluded_ids_ = excluded_ids;
 
   if (UsesHostRestrictions() && hosts_.empty()) {
-    FetchFinished(OptionalSnippets(), FetchResult::EMPTY_HOSTS,
+    FetchFinished(OptionalFetchedCategories(), FetchResult::EMPTY_HOSTS,
                   /*extra_message=*/std::string());
     return;
   }
 
   locale_ = PosixLocaleFromBCP47Language(language_code);
   count_to_fetch_ = count;
 
   bool use_authentication = UsesAuthentication();
   interactive_request_ = interactive_request;
 
@@ skipping 226 matching lines @@
       error.state() == GoogleServiceAuthError::State::REQUEST_CANCELED) {
     // The request (especially on startup) can get reset by loading the refresh
     // token - do it one more time.
     oauth_token_retried_ = true;
     StartTokenRequest();
     return;
   }
 
   DLOG(ERROR) << "Unable to get token: " << error.ToString();
   FetchFinished(
-      OptionalSnippets(), FetchResult::OAUTH_TOKEN_ERROR,
+      OptionalFetchedCategories(), FetchResult::OAUTH_TOKEN_ERROR,
       /*extra_message=*/base::StringPrintf(" (%s)", error.ToString().c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OAuth2TokenService::Observer overrides
 void NTPSnippetsFetcher::OnRefreshTokenAvailable(
     const std::string& account_id) {
   // Only react on tokens for the account the user has signed in with.
   if (account_id != signin_manager_->GetAuthenticatedAccountId())
     return;
 
   token_service_->RemoveObserver(this);
   waiting_for_refresh_token_ = false;
   oauth_token_retried_ = false;
   StartTokenRequest();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // URLFetcherDelegate overrides
 void NTPSnippetsFetcher::OnURLFetchComplete(const URLFetcher* source) {
   DCHECK_EQ(url_fetcher_.get(), source);
 
   const URLRequestStatus& status = source->GetStatus();
 
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "NewTabPage.Snippets.FetchHttpResponseOrErrorCode",
       status.is_success() ? source->GetResponseCode() : status.error());
 
   if (!status.is_success()) {
-    FetchFinished(OptionalSnippets(), FetchResult::URL_REQUEST_STATUS_ERROR,
+    FetchFinished(OptionalFetchedCategories(),
+                  FetchResult::URL_REQUEST_STATUS_ERROR,
                   /*extra_message=*/base::StringPrintf(" %d", status.error()));
   } else if (source->GetResponseCode() != net::HTTP_OK) {
     // TODO(jkrcal): https://crbug.com/609084
     // We need to deal with the edge case again where the auth
     // token expires just before we send the request (in which case we need to
     // fetch a new auth token). We should extract that into a common class
     // instead of adding it to every single class that uses auth tokens.
     FetchFinished(
-        OptionalSnippets(), FetchResult::HTTP_ERROR,
+        OptionalFetchedCategories(), FetchResult::HTTP_ERROR,
         /*extra_message=*/base::StringPrintf(" %d", source->GetResponseCode()));
   } else {
     bool stores_result_to_string =
         source->GetResponseAsString(&last_fetch_json_);
     DCHECK(stores_result_to_string);
 
     parse_json_callback_.Run(last_fetch_json_,
                              base::Bind(&NTPSnippetsFetcher::OnJsonParsed,
                                         weak_ptr_factory_.GetWeakPtr()),
                              base::Bind(&NTPSnippetsFetcher::OnJsonError,
@@ skipping 54 matching lines @@
       return true;
     }
   }
   NOTREACHED();
   return false;
 }
 
 void NTPSnippetsFetcher::OnJsonParsed(std::unique_ptr<base::Value> parsed) {
   FetchedCategoriesVector categories;
   if (JsonToSnippets(*parsed, &categories)) {
-    FetchFinished(OptionalSnippets(std::move(categories)), FetchResult::SUCCESS,
+    FetchFinished(OptionalFetchedCategories(std::move(categories)),
+                  FetchResult::SUCCESS,
                   /*extra_message=*/std::string());
   } else {
     LOG(WARNING) << "Received invalid snippets: " << last_fetch_json_;
-    FetchFinished(OptionalSnippets(),
+    FetchFinished(OptionalFetchedCategories(),
                   FetchResult::INVALID_SNIPPET_CONTENT_ERROR,
                   /*extra_message=*/std::string());
   }
 }
 
 void NTPSnippetsFetcher::OnJsonError(const std::string& error) {
   LOG(WARNING) << "Received invalid JSON (" << error
                << "): " << last_fetch_json_;
   FetchFinished(
-      OptionalSnippets(), FetchResult::JSON_PARSE_ERROR,
+      OptionalFetchedCategories(), FetchResult::JSON_PARSE_ERROR,
       /*extra_message=*/base::StringPrintf(" (error %s)", error.c_str()));
 }
 
-void NTPSnippetsFetcher::FetchFinished(OptionalSnippets snippets,
-                                       FetchResult result,
-                                       const std::string& extra_message) {
-  DCHECK(result == FetchResult::SUCCESS || !snippets);
+void NTPSnippetsFetcher::FetchFinished(
+    OptionalFetchedCategories fetched_categories,
+    FetchResult result,
+    const std::string& extra_message) {
+  DCHECK(result == FetchResult::SUCCESS || !fetched_categories);
   last_status_ = FetchResultToString(result) + extra_message;
 
   // Don't record FetchTimes if the result indicates that a precondition
   // failed and we never actually sent a network request
   if (!IsFetchPreconditionFailed(result)) {
     UMA_HISTOGRAM_TIMES("NewTabPage.Snippets.FetchTime",
                         tick_clock_->NowTicks() - fetch_start_time_);
   }
   UMA_HISTOGRAM_ENUMERATION("NewTabPage.Snippets.FetchResult",
                             static_cast<int>(result),
                             static_cast<int>(FetchResult::RESULT_MAX));
 
   DVLOG(1) << "Fetch finished: " << last_status_;
   if (!snippets_available_callback_.is_null())
-    snippets_available_callback_.Run(std::move(snippets));
+    snippets_available_callback_.Run(std::move(fetched_categories));
 }
 
 }  // namespace ntp_snippets