Remove raw base::DictionaryValue::Set

printing/print_settings_conversion.cc

 // Copyright 2014 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 "printing/print_settings_conversion.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "printing/page_size_margins.h"
 #include "printing/print_job_constants.h"
 #include "printing/print_settings.h"
 #include "printing/units.h"
 
 namespace printing {
@@ skipping 12 matching lines @@
                                  &page_size_margins->margin_left) ||
       !custom_margins->GetDouble(kSettingMarginRight,
                                  &page_size_margins->margin_right)) {
     NOTREACHED();
   }
 }
 
 void SetMarginsToJobSettings(const std::string& json_path,
                              const PageMargins& margins,
                              base::DictionaryValue* job_settings) {
-  base::DictionaryValue* dict = new base::DictionaryValue;
-  job_settings->Set(json_path, dict);
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger(kSettingMarginTop, margins.top);
   dict->SetInteger(kSettingMarginBottom, margins.bottom);
   dict->SetInteger(kSettingMarginLeft, margins.left);
   dict->SetInteger(kSettingMarginRight, margins.right);
+  job_settings->Set(json_path, std::move(dict));
 }
 
 void SetSizeToJobSettings(const std::string& json_path,
                           const gfx::Size& size,
                           base::DictionaryValue* job_settings) {
-  base::DictionaryValue* dict = new base::DictionaryValue;
-  job_settings->Set(json_path, dict);
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("width", size.width());
   dict->SetInteger("height", size.height());
+  job_settings->Set(json_path, std::move(dict));
 }
 
 void SetRectToJobSettings(const std::string& json_path,
                           const gfx::Rect& rect,
                           base::DictionaryValue* job_settings) {
-  base::DictionaryValue* dict = new base::DictionaryValue;
-  job_settings->Set(json_path, dict);
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("x", rect.x());
   dict->SetInteger("y", rect.y());
   dict->SetInteger("width", rect.width());
   dict->SetInteger("height", rect.height());
+  job_settings->Set(json_path, std::move(dict));
 }
 
 }  // namespace
 
 bool PrintSettingsFromJobSettings(const base::DictionaryValue& job_settings,
                                   PrintSettings* settings) {
   bool display_header_footer = false;
   if (!job_settings.GetBoolean(kSettingHeaderFooterEnabled,
                                &display_header_footer)) {
     return false;
@@ skipping 139 matching lines @@
   job_settings->SetBoolean(kSettingHeaderFooterEnabled,
                            settings.display_header_footer());
   job_settings->SetString(kSettingHeaderFooterTitle, settings.title());
   job_settings->SetString(kSettingHeaderFooterURL, settings.url());
   job_settings->SetBoolean(kSettingShouldPrintBackgrounds,
                            settings.should_print_backgrounds());
   job_settings->SetBoolean(kSettingShouldPrintSelectionOnly,
                            settings.selection_only());
   job_settings->SetInteger(kSettingMarginsType, settings.margin_type());
   if (!settings.ranges().empty()) {
-    base::ListValue* page_range_array = new base::ListValue;
-    job_settings->Set(kSettingPageRange, page_range_array);
+    auto page_range_array = base::MakeUnique<base::ListValue>();
     for (size_t i = 0; i < settings.ranges().size(); ++i) {
-      std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+      auto dict = base::MakeUnique<base::DictionaryValue>();
       dict->SetInteger(kSettingPageRangeFrom, settings.ranges()[i].from + 1);
       dict->SetInteger(kSettingPageRangeTo, settings.ranges()[i].to + 1);
       page_range_array->Append(std::move(dict));
     }
+    job_settings->Set(kSettingPageRange, std::move(page_range_array));
   }
 
   job_settings->SetBoolean(kSettingCollate, settings.collate());
   job_settings->SetInteger(kSettingCopies, settings.copies());
   job_settings->SetInteger(kSettingColor, settings.color());
   job_settings->SetInteger(kSettingDuplexMode, settings.duplex_mode());
   job_settings->SetBoolean(kSettingLandscape, settings.landscape());
   job_settings->SetString(kSettingDeviceName, settings.device_name());
 
   // Following values are not read form JSON by InitSettings, so do not have
   // common public constants. So just serialize in "debug" section.
-  base::DictionaryValue* debug = new base::DictionaryValue;
-  job_settings->Set("debug", debug);
+  auto debug = base::MakeUnique<base::DictionaryValue>();
   debug->SetInteger("dpi", settings.dpi());
   debug->SetInteger("deviceUnitsPerInch", settings.device_units_per_inch());
   debug->SetBoolean("support_alpha_blend", settings.should_print_backgrounds());
   debug->SetString("media_vendor_id", settings.requested_media().vendor_id);
-  SetSizeToJobSettings(
-      "media_size", settings.requested_media().size_microns, debug);
+  SetSizeToJobSettings("media_size", settings.requested_media().size_microns,
+                       debug.get());
   SetMarginsToJobSettings("requested_custom_margins_in_points",
                           settings.requested_custom_margins_in_points(),
-                          debug);
+                          debug.get());
   const PageSetup& page_setup = settings.page_setup_device_units();
-  SetMarginsToJobSettings(
-      "effective_margins", page_setup.effective_margins(), debug);
-  SetSizeToJobSettings("physical_size", page_setup.physical_size(), debug);
-  SetRectToJobSettings("overlay_area", page_setup.overlay_area(), debug);
-  SetRectToJobSettings("content_area", page_setup.content_area(), debug);
-  SetRectToJobSettings("printable_area", page_setup.printable_area(), debug);
+  SetMarginsToJobSettings("effective_margins", page_setup.effective_margins(),
+                          debug.get());
+  SetSizeToJobSettings("physical_size", page_setup.physical_size(),
+                       debug.get());
+  SetRectToJobSettings("overlay_area", page_setup.overlay_area(), debug.get());
+  SetRectToJobSettings("content_area", page_setup.content_area(), debug.get());
+  SetRectToJobSettings("printable_area", page_setup.printable_area(),
+                       debug.get());
+  job_settings->Set("debug", std::move(debug));
 }
 
 }  // namespace printing