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

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 120 matching lines @@
 std::string GetFetchEndpoint() {
   std::string endpoint = variations::GetVariationParamValue(
       ntp_snippets::kStudyName, kContentSuggestionsBackend);
   return endpoint.empty() ? kChromeReaderServer : endpoint;
 }
 
 bool IsBooleanParameterEnabled(const std::string& param_name,
                                bool default_value) {
   std::string param_value = variations::GetVariationParamValueByFeature(
         ntp_snippets::kArticleSuggestionsFeature, param_name);
-  if (param_value == kBooleanParameterEnabled)
+  if (param_value == kBooleanParameterEnabled) {
     return true;
-  if (param_value == kBooleanParameterDisabled)
+  }
+  if (param_value == kBooleanParameterDisabled) {
     return false;
+  }
   if (!param_value.empty()) {
     LOG(WARNING) << "Invalid value \"" << param_value
                  << "\" for variation parameter " << param_name;
   }
   return default_value;
 }
 
 bool IsSendingTopLanguagesEnabled() {
   return IsBooleanParameterEnabled(kSendTopLanguagesName, false);
 }
 
 bool IsSendingUserClassEnabled() {
   return IsBooleanParameterEnabled(kSendUserClassName, false);
 }
 
 bool UsesChromeContentSuggestionsAPI(const GURL& endpoint) {
-  if (endpoint == kChromeReaderServer)
+  if (endpoint == kChromeReaderServer) {
     return false;
+  }
 
   if (endpoint != kContentSuggestionsServer &&
       endpoint != kContentSuggestionsStagingServer &&
       endpoint != kContentSuggestionsAlphaServer) {
     LOG(WARNING) << "Unknown value for " << kContentSuggestionsBackend << ": "
                  << "assuming chromecontentsuggestions-style API";
   }
   return true;
 }
 
@@ skipping 177 matching lines @@
   } else {
     personalization_ = Personalization::kBoth;
     LOG_IF(WARNING, !personalization.empty() &&
                         personalization != kPersonalizationBothString)
         << "Unknown value for " << kPersonalizationName << ": "
         << personalization;
   }
 }
 
 NTPSnippetsFetcher::~NTPSnippetsFetcher() {
-  if (waiting_for_refresh_token_)
+  if (waiting_for_refresh_token_) {
     token_service_->RemoveObserver(this);
+  }
 }
 
 void NTPSnippetsFetcher::FetchSnippets(const Params& params,
                                        SnippetsAvailableCallback callback) {
   if (!DemandQuotaForRequest(params.interactive_request)) {
     FetchFinished(OptionalFetchedCategories(),
                   params.interactive_request
                       ? FetchResult::INTERACTIVE_QUOTA_ERROR
                       : FetchResult::NON_INTERACTIVE_QUOTA_ERROR,
                   /*extra_message=*/std::string());
@@ skipping 99 matching lines @@
         regular_hosts->AppendString(host);
       }
       request->Set("regularlyVisitedHostNames", std::move(regular_hosts));
       request->SetString("priority", params.interactive_request
                                          ? "USER_ACTION"
                                          : "BACKGROUND_PREFETCH");
 
       auto excluded = base::MakeUnique<base::ListValue>();
       for (const auto& id : params.excluded_ids) {
         excluded->AppendString(id);
-        if (excluded->GetSize() >= kMaxExcludedIds)
+        if (excluded->GetSize() >= kMaxExcludedIds) {
           break;
+        }
       }
       request->Set("excludedSuggestionIds", std::move(excluded));
 
-      if (!user_class.empty())
+      if (!user_class.empty()) {
         request->SetString("userActivenessClass", user_class);
+      }
 
-      if (ui_language.frequency == 0 && other_top_language.frequency == 0)
+      if (ui_language.frequency == 0 && other_top_language.frequency == 0) {
         break;
+      }
 
       auto language_list = base::MakeUnique<base::ListValue>();
-      if (ui_language.frequency > 0)
+      if (ui_language.frequency > 0) {
         AppendLanguageInfoToList(language_list.get(), ui_language);
-      if (other_top_language.frequency > 0)
+      }
+      if (other_top_language.frequency > 0) {
         AppendLanguageInfoToList(language_list.get(), other_top_language);
+      }
       request->Set("topLanguages", std::move(language_list));
 
       // TODO(sfiera): Support only_return_personalized_results.
       // 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);
   return request_json;
 }
 
 void NTPSnippetsFetcher::FetchSnippetsImpl(const GURL& url,
                                            const std::string& auth_header,
                                            const std::string& request) {
   url_fetcher_ = URLFetcher::Create(url, URLFetcher::POST, this);
 
   url_fetcher_->SetRequestContext(url_request_context_getter_.get());
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SAVE_COOKIES);
 
   data_use_measurement::DataUseUserData::AttachToFetcher(
       url_fetcher_.get(), data_use_measurement::DataUseUserData::NTP_SNIPPETS);
 
   HttpRequestHeaders headers;
-  if (!auth_header.empty())
+  if (!auth_header.empty()) {
     headers.SetHeader("Authorization", auth_header);
+  }
   headers.SetHeader("Content-Type", "application/json; charset=UTF-8");
   // Add X-Client-Data header with experiment IDs from field trials.
   variations::AppendVariationHeaders(url,
                                      false,  // incognito
                                      false,  // uma_enabled
                                      &headers);
   url_fetcher_->SetExtraRequestHeaders(headers.ToString());
   url_fetcher_->SetUploadData("application/json", request);
   // Log the request for debugging network issues.
   VLOG(1) << "Sending a NTP snippets request to " << url << ":" << std::endl
@@ skipping 10 matching lines @@
   return (personalization_ == Personalization::kPersonal ||
           personalization_ == Personalization::kBoth);
 }
 
 NTPSnippetsFetcher::RequestBuilder NTPSnippetsFetcher::MakeRequestBuilder()
     const {
   RequestBuilder result;
   result.params = params_;
   result.fetch_api = fetch_api_;
 
-  if (IsSendingUserClassEnabled())
+  if (IsSendingUserClassEnabled()) {
     result.user_class = GetUserClassString(user_classifier_->GetUserClass());
+  }
 
   // TODO(jkrcal): Add language model factory for iOS and add fakes to tests so
   // that |language_model_| is never nullptr. Remove this check and add a DCHECK
   // into the constructor.
-  if (!language_model_ || !IsSendingTopLanguagesEnabled())
+  if (!language_model_ || !IsSendingTopLanguagesEnabled()) {
     return result;
+  }
 
   // TODO(jkrcal): Is this back-and-forth converting necessary?
   result.ui_language.language_code = ISO639FromPosixLocale(
       PosixLocaleFromBCP47Language(result.params.language_code));
   result.ui_language.frequency =
       language_model_->GetLanguageFrequency(result.ui_language.language_code);
 
   std::vector<LanguageModel::LanguageInfo> top_languages =
       language_model_->GetTopLanguages();
   for (const LanguageModel::LanguageInfo& info : top_languages) {
@@ skipping 79 matching lines @@
   FetchFinished(
       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())
+  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) {
@@ skipping 125 matching lines @@
                << "): " << last_fetch_json_;
   FetchFinished(
       OptionalFetchedCategories(), FetchResult::JSON_PARSE_ERROR,
       /*extra_message=*/base::StringPrintf(" (error %s)", error.c_str()));
 }
 
 // The response from the backend might include suggestions from multiple
 // categories. If only fetches for a single category were requested, this
 // function filters them out.
 void NTPSnippetsFetcher::FilterCategories(FetchedCategoriesVector* categories) {
-  if (!params_.exclusive_category.has_value())
+  if (!params_.exclusive_category.has_value()) {
     return;
+  }
   Category exclusive = params_.exclusive_category.value();
   auto category_it =
       std::find_if(categories->begin(), categories->end(),
                    [&exclusive](const FetchedCategory& c) -> bool {
                      return c.category == exclusive;
                    });
   if (category_it == categories->end()) {
     categories->clear();
     return;
   }
   FetchedCategory category = std::move(*category_it);
   categories->clear();
   categories->emplace_back(std::move(category));
 }
 
 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;
 
   // Filter out unwanted categories if necessary.
   // TODO(fhorschig): As soon as the server supports filtering by
   // that instead of over-fetching and filtering here.
-  if (fetched_categories.has_value())
+  if (fetched_categories.has_value()) {
     FilterCategories(&fetched_categories.value());
+  }
 
   // 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())
+  if (!snippets_available_callback_.is_null()) {
     std::move(snippets_available_callback_).Run(std::move(fetched_categories));
+  }
 }
 
 bool NTPSnippetsFetcher::DemandQuotaForRequest(bool interactive_request) {
   switch (user_classifier_->GetUserClass()) {
     case UserClassifier::UserClass::RARE_NTP_USER:
       return request_throttler_rare_ntp_user_.DemandQuotaForRequest(
           interactive_request);
     case UserClassifier::UserClass::ACTIVE_NTP_USER:
       return request_throttler_active_ntp_user_.DemandQuotaForRequest(
           interactive_request);
     case UserClassifier::UserClass::ACTIVE_SUGGESTIONS_CONSUMER:
       return request_throttler_active_suggestions_consumer_
           .DemandQuotaForRequest(interactive_request);
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace ntp_snippets