Remove raw DictionaryValue::Set in //components

components/error_page/common/localized_error.cc

 // Copyright (c) 2012 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/error_page/common/localized_error.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 488 matching lines @@
       suggestion->GetString("urlCorrection", &cache_url);
       int cache_tracking_id = -1;
       suggestion->GetInteger("trackingId", &cache_tracking_id);
       std::unique_ptr<base::DictionaryValue> cache_button(
           new base::DictionaryValue);
       cache_button->SetString(
             "msg",
             l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY));
       cache_button->SetString("cacheUrl", cache_url);
       cache_button->SetInteger("trackingId", cache_tracking_id);
-      error_strings->Set("cacheButton", cache_button.release());
+      error_strings->Set("cacheButton", std::move(cache_button));
 
       // Remove the item from suggestions dictionary so that it does not get
       // displayed by the template in the details section.
       suggestions_summary_list->Remove(0, nullptr);
     }
   }
 }
 
 // Helper function that creates a single entry dictionary and adds it
 // to a ListValue,
@@ skipping 373 matching lines @@
 
   base::string16 host_name(url_formatter::IDNToUnicode(failed_url.host()));
   if (failed_url.SchemeIsHTTPOrHTTPS())
     error_strings->SetString("title", host_name);
   else
     error_strings->SetString("title", failed_url_string);
 
   std::string icon_class = GetIconClassForError(error_domain, error_code);
   error_strings->SetString("iconClass", icon_class);
 
-  base::DictionaryValue* heading = new base::DictionaryValue;
+  auto heading = base::MakeUnique<base::DictionaryValue>();
   heading->SetString("msg",
                      l10n_util::GetStringUTF16(options.heading_resource_id));
   heading->SetString("hostName", host_name);
-  error_strings->Set("heading", heading);
+  error_strings->Set("heading", std::move(heading));
 
-  base::DictionaryValue* summary = new base::DictionaryValue;
+  auto summary = base::MakeUnique<base::DictionaryValue>();
 
   // Set summary message under the heading.
   summary->SetString(
       "msg", l10n_util::GetStringUTF16(options.summary_resource_id));
 
   // Add a DNS definition string.
   summary->SetString("dnsDefinition",
       l10n_util::GetStringUTF16(IDS_ERRORPAGES_SUMMARY_DNS_DEFINITION));
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   // Check if easter egg should be disabled.
   if (command_line->HasSwitch(
           error_page::switches::kDisableDinosaurEasterEgg)) {
     // The presence of this string disables the easter egg. Acts as a flag.
     error_strings->SetString("disabledEasterEgg",
         l10n_util::GetStringUTF16(IDS_ERRORPAGE_FUN_DISABLED));
   }
 
   summary->SetString("failedUrl", failed_url_string);
   summary->SetString("hostName", host_name);
 
   error_strings->SetString(
       "details", l10n_util::GetStringUTF16(IDS_ERRORPAGE_NET_BUTTON_DETAILS));
   error_strings->SetString(
       "hideDetails", l10n_util::GetStringUTF16(
           IDS_ERRORPAGE_NET_BUTTON_HIDE_DETAILS));
-  error_strings->Set("summary", summary);
+  error_strings->Set("summary", std::move(summary));
 
   base::string16 error_string;
   if (error_domain == net::kErrorDomain) {
     // Non-internationalized error string, for debugging Chrome itself.
     error_string = base::ASCIIToUTF16(net::ErrorToShortString(error_code));
   } else if (error_domain == error_page::kDnsProbeErrorDomain) {
     std::string ascii_error_string =
         error_page::DnsProbeStatusToString(error_code);
     error_string = base::ASCIIToUTF16(ascii_error_string);
   } else {
     DCHECK_EQ(LocalizedError::kHttpErrorDomain, error_domain);
     error_string = base::ASCIIToUTF16(HttpErrorCodeToString(error_code));
   }
   error_strings->SetString("errorCode", error_string);
 
   // If no parameters were provided, use the defaults.
   if (!params) {
     params.reset(new error_page::ErrorPageParams());
     params->suggest_reload = !!(options.buttons && SHOW_BUTTON_RELOAD);
   }
 
   base::ListValue* suggestions_details = nullptr;
   base::ListValue* suggestions_summary_list = nullptr;
 
   bool use_default_suggestions = true;
   if (!params->override_suggestions) {
-    suggestions_details = new base::ListValue();
-    suggestions_summary_list = new base::ListValue();
     // Detailed suggestion information.
-    error_strings->Set("suggestionsDetails", suggestions_details);
+    suggestions_details = error_strings->SetList(
+        "suggestionsDetails", base::MakeUnique<base::ListValue>());
+    suggestions_summary_list = error_strings->SetList(
+        "suggestionsSummaryList", base::MakeUnique<base::ListValue>());
   } else {
-    suggestions_summary_list = params->override_suggestions.release();
+    suggestions_summary_list = error_strings->SetList(
+        "suggestionsSummaryList", std::move(params->override_suggestions));
     use_default_suggestions = false;
     AddGoogleCachedCopyButton(suggestions_summary_list, error_strings);
   }
-  error_strings->Set("suggestionsSummaryList", suggestions_summary_list);
 
   if (params->search_url.is_valid()) {
     std::unique_ptr<base::DictionaryValue> search_suggestion(
         new base::DictionaryValue);
     search_suggestion->SetString("summary",l10n_util::GetStringUTF16(
         IDS_ERRORPAGES_SUGGESTION_GOOGLE_SEARCH_SUMMARY));
     search_suggestion->SetString("searchUrl", params->search_url.spec() +
                                  params->search_terms);
     search_suggestion->SetString("searchTerms", params->search_terms);
     search_suggestion->SetInteger("trackingId",
                                   params->search_tracking_id);
     suggestions_summary_list->Append(std::move(search_suggestion));
   }
 
   // Add the reload suggestion, if needed for pages that didn't come
   // from a post.
 #if defined(OS_ANDROID)
   bool reload_visible = false;
 #endif  // defined(OS_ANDROID)
   if (params->suggest_reload && !is_post) {
 #if defined(OS_ANDROID)
     reload_visible = true;
 #endif  // defined(OS_ANDROID)
-    base::DictionaryValue* reload_button = new base::DictionaryValue;
+    auto reload_button = base::MakeUnique<base::DictionaryValue>();
     reload_button->SetString(
         "msg", l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_RELOAD));
     reload_button->SetString("reloadUrl", failed_url.spec());
-    error_strings->Set("reloadButton", reload_button);
     reload_button->SetInteger("reloadTrackingId", params->reload_tracking_id);
+    error_strings->Set("reloadButton", std::move(reload_button));
   }
 
   // If not using the default suggestions, nothing else to do.
   if (!use_default_suggestions)
     return;
 
 #if defined(OS_CHROMEOS)
   // ChromeOS has its own diagnostics extension, which doesn't rely on a
   // browser-initiated dialog.
   can_show_network_diagnostics_dialog = true;
@@ skipping 13 matching lines @@
       (show_saved_copy_value ==
        error_page::switches::kEnableShowSavedCopyPrimary);
   bool show_saved_copy_secondary =
       (show_saved_copy_value ==
        error_page::switches::kEnableShowSavedCopySecondary);
   bool show_saved_copy_visible =
       (stale_copy_in_cache && !is_post &&
       (show_saved_copy_primary || show_saved_copy_secondary));
 
   if (show_saved_copy_visible) {
-    base::DictionaryValue* show_saved_copy_button = new base::DictionaryValue;
+    auto show_saved_copy_button = base::MakeUnique<base::DictionaryValue>();
     show_saved_copy_button->SetString(
         "msg", l10n_util::GetStringUTF16(
             IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY));
     show_saved_copy_button->SetString(
         "title",
         l10n_util::GetStringUTF16(IDS_ERRORPAGES_BUTTON_SHOW_SAVED_COPY_HELP));
     if (show_saved_copy_primary)
       show_saved_copy_button->SetString("primary", "true");
-    error_strings->Set("showSavedCopyButton", show_saved_copy_button);
+    error_strings->Set("showSavedCopyButton",
+                       std::move(show_saved_copy_button));
   }
 
 #if defined(OS_ANDROID)
   if (!is_post && !reload_visible && !show_saved_copy_visible &&
       !is_incognito && failed_url.is_valid() &&
       failed_url.SchemeIsHTTPOrHTTPS() &&
       IsSuggested(options.suggestions, SUGGEST_OFFLINE_CHECKS) &&
       offline_pages::IsOfflinePagesAsyncDownloadEnabled()) {
     std::unique_ptr<base::DictionaryValue> download_button =
         base::MakeUnique<base::DictionaryValue>();
@@ skipping 21 matching lines @@
 
 bool LocalizedError::HasStrings(const std::string& error_domain,
                                 int error_code) {
   // Whether or not the there are strings for an error does not depend on
   // whether or not the page was be generated by a POST, so just claim it was
   // not.
   return LookupErrorMap(error_domain, error_code, /*is_post=*/false) != nullptr;
 }
 
 }  // namespace error_page