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

components/ntp_snippets/remote/ntp_snippet.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/remote/ntp_snippet.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 40 matching lines @@
       is_dismissed_(false),
       remote_category_id_(remote_category_id),
       best_source_index_(0) {}
 
 NTPSnippet::~NTPSnippet() = default;
 
 // static
 std::unique_ptr<NTPSnippet> NTPSnippet::CreateFromChromeReaderDictionary(
     const base::DictionaryValue& dict) {
   const base::DictionaryValue* content = nullptr;
-  if (!dict.GetDictionary("contentInfo", &content))
+  if (!dict.GetDictionary("contentInfo", &content)) {
     return nullptr;
+  }
 
   // Need at least the id.
   std::string id;
-  if (!content->GetString("url", &id) || id.empty())
+  if (!content->GetString("url", &id) || id.empty()) {
     return nullptr;
+  }
 
   std::unique_ptr<NTPSnippet> snippet(new NTPSnippet(id, kArticlesRemoteId));
 
   std::string title;
-  if (content->GetString("title", &title))
+  if (content->GetString("title", &title)) {
     snippet->set_title(title);
+  }
   std::string salient_image_url;
-  if (content->GetString("thumbnailUrl", &salient_image_url))
+  if (content->GetString("thumbnailUrl", &salient_image_url)) {
     snippet->set_salient_image_url(GURL(salient_image_url));
+  }
   std::string snippet_str;
-  if (content->GetString("snippet", &snippet_str))
+  if (content->GetString("snippet", &snippet_str)) {
     snippet->set_snippet(snippet_str);
+  }
   // The creation and expiry timestamps are uint64s which are stored as strings.
   std::string creation_timestamp_str;
-  if (content->GetString("creationTimestampSec", &creation_timestamp_str))
+  if (content->GetString("creationTimestampSec", &creation_timestamp_str)) {
     snippet->set_publish_date(TimeFromJsonString(creation_timestamp_str));
+  }
   std::string expiry_timestamp_str;
-  if (content->GetString("expiryTimestampSec", &expiry_timestamp_str))
+  if (content->GetString("expiryTimestampSec", &expiry_timestamp_str)) {
     snippet->set_expiry_date(TimeFromJsonString(expiry_timestamp_str));
+  }
 
   const base::ListValue* corpus_infos_list = nullptr;
   if (!content->GetList("sourceCorpusInfo", &corpus_infos_list)) {
     DLOG(WARNING) << "No sources found for article " << title;
     return nullptr;
   }
 
   std::vector<std::string> additional_ids;
   for (const auto& value : *corpus_infos_list) {
     const base::DictionaryValue* dict_value = nullptr;
     if (!value->GetAsDictionary(&dict_value)) {
       DLOG(WARNING) << "Invalid source info for article " << id;
       continue;
     }
 
     std::string corpus_id_str;
     GURL corpus_id;
-    if (dict_value->GetString("corpusId", &corpus_id_str))
+    if (dict_value->GetString("corpusId", &corpus_id_str)) {
       corpus_id = GURL(corpus_id_str);
+    }
 
     if (!corpus_id.is_valid()) {
       // We must at least have a valid source URL.
       DLOG(WARNING) << "Invalid article url " << corpus_id_str;
       continue;
     }
     const base::DictionaryValue* publisher_data = nullptr;
     std::string site_title;
     if (dict_value->GetDictionary("publisherData", &publisher_data)) {
       if (!publisher_data->GetString("sourceName", &site_title)) {
@@ skipping 23 matching lines @@
   snippet->AddIDs(additional_ids);
 
   if (snippet->sources_.empty()) {
     DLOG(WARNING) << "No sources found for article " << id;
     return nullptr;
   }
 
   snippet->InitBestSource();
 
   double score;
-  if (dict.GetDouble("score", &score))
+  if (dict.GetDouble("score", &score)) {
     snippet->set_score(score);
+  }
 
   return snippet;
 }
 
 // static
 std::unique_ptr<NTPSnippet> NTPSnippet::CreateFromContentSuggestionsDictionary(
     const base::DictionaryValue& dict,
     int remote_category_id) {
   const base::ListValue* ids;
-  if (!dict.GetList("ids", &ids)) return nullptr;
+  if (!dict.GetList("ids", &ids)) {
+    return nullptr;
+  }
   std::vector<std::string> parsed_ids;
   for (const auto& value : *ids) {
     std::string id;
-    if (!value->GetAsString(&id)) return nullptr;
+    if (!value->GetAsString(&id)) {
+      return nullptr;
+    }
     parsed_ids.push_back(id);
   }
 
-  if (parsed_ids.empty()) return nullptr;
+  if (parsed_ids.empty()) {
+    return nullptr;
+  }
   auto snippet =
       base::MakeUnique<NTPSnippet>(parsed_ids.front(), remote_category_id);
   parsed_ids.erase(parsed_ids.begin(), parsed_ids.begin() + 1);
   snippet->AddIDs(parsed_ids);
 
   snippet->sources_.emplace_back(GURL(), std::string(), GURL());
   auto* source = &snippet->sources_.back();
   snippet->best_source_index_ = 0;
 
   if (!(dict.GetString("title", &snippet->title_) &&
         dict.GetString("snippet", &snippet->snippet_) &&
         GetTimeValue(dict, "creationTime", &snippet->publish_date_) &&
         GetTimeValue(dict, "expirationTime", &snippet->expiry_date_) &&
         GetURLValue(dict, "imageUrl", &snippet->salient_image_url_) &&
         dict.GetString("attribution", &source->publisher_name) &&
         GetURLValue(dict, "fullPageUrl", &source->url))) {
     return nullptr;
   }
   GetURLValue(dict, "ampUrl", &source->amp_url);  // May fail; OK.
   // TODO(sfiera): also favicon URL.
 
   double score;
-  if (dict.GetDouble("score", &score))
+  if (dict.GetDouble("score", &score)) {
     snippet->set_score(score);
+  }
 
   return snippet;
 }
 
 // static
 std::unique_ptr<NTPSnippet> NTPSnippet::CreateFromProto(
     const SnippetProto& proto) {
   // Need at least the id.
-  if (proto.ids_size() == 0 || proto.ids(0).empty())
+  if (proto.ids_size() == 0 || proto.ids(0).empty()) {
     return nullptr;
+  }
 
   int remote_category_id = proto.has_remote_category_id()
                                ? proto.remote_category_id()
                                : kArticlesRemoteId;
 
   auto snippet = base::MakeUnique<NTPSnippet>(proto.ids(0), remote_category_id);
   snippet->AddIDs(
       std::vector<std::string>(proto.ids().begin() + 1, proto.ids().end()));
 
   snippet->set_title(proto.title());
@@ skipping 32 matching lines @@
   snippet->InitBestSource();
 
   return snippet;
 }
 
 SnippetProto NTPSnippet::ToProto() const {
   SnippetProto result;
   for (const std::string& id : ids_) {
     result.add_ids(id);
   }
-  if (!title_.empty())
+  if (!title_.empty()) {
     result.set_title(title_);
-  if (!snippet_.empty())
+  }
+  if (!snippet_.empty()) {
     result.set_snippet(snippet_);
-  if (salient_image_url_.is_valid())
+  }
+  if (salient_image_url_.is_valid()) {
     result.set_salient_image_url(salient_image_url_.spec());
-  if (!publish_date_.is_null())
+  }
+  if (!publish_date_.is_null()) {
     result.set_publish_date(publish_date_.ToInternalValue());
-  if (!expiry_date_.is_null())
+  }
+  if (!expiry_date_.is_null()) {
     result.set_expiry_date(expiry_date_.ToInternalValue());
+  }
   result.set_score(score_);
   result.set_dismissed(is_dismissed_);
   result.set_remote_category_id(remote_category_id_);
 
   for (const SnippetSource& source : sources_) {
     SnippetSourceProto* source_proto = result.add_sources();
     source_proto->set_url(source.url.spec());
-    if (!source.publisher_name.empty())
+    if (!source.publisher_name.empty()) {
       source_proto->set_publisher_name(source.publisher_name);
-    if (source.amp_url.is_valid())
+    }
+    if (source.amp_url.is_valid()) {
       source_proto->set_amp_url(source.amp_url.spec());
+    }
   }
 
   return result;
 }
 
 void NTPSnippet::AddIDs(const std::vector<std::string>& ids) {
   ids_.insert(ids_.end(), ids.begin(), ids.end());
 }
 
 // static
@@ skipping 28 matching lines @@
       best_source_index_ = i;
       if (!source.amp_url.is_empty()) {
         // This is the best possible source, stop looking.
         break;
       }
     }
   }
 }
 
 }  // namespace ntp_snippets