Remove raw base::DictionaryValue::Set in //extensions

extensions/browser/api/web_request/web_request_api_helpers.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 "extensions/browser/api/web_request/web_request_api_helpers.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/api/web_request/web_request_api_constants.h"
 #include "extensions/browser/extension_registry.h"
@@ skipping 190 matching lines @@
 // callback.
 net::NetLogParametersCallback CreateNetLogExtensionIdCallback(
     const EventResponseDelta* delta) {
   return net::NetLog::StringCallback("extension_id", &delta->extension_id);
 }
 
 // Creates NetLog parameters to indicate that an extension modified a request.
 std::unique_ptr<base::Value> NetLogModificationCallback(
     const EventResponseDelta* delta,
     net::NetLogCaptureMode capture_mode) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString("extension_id", delta->extension_id);
 
-  base::ListValue* modified_headers = new base::ListValue();
+  auto modified_headers = base::MakeUnique<base::ListValue>();
   net::HttpRequestHeaders::Iterator modification(
       delta->modified_request_headers);
   while (modification.GetNext()) {
     std::string line = modification.name() + ": " + modification.value();
     modified_headers->AppendString(line);
   }
-  dict->Set("modified_headers", modified_headers);
+  dict->Set("modified_headers", std::move(modified_headers));
 
-  base::ListValue* deleted_headers = new base::ListValue();
+  auto deleted_headers = base::MakeUnique<base::ListValue>();
   for (std::vector<std::string>::const_iterator key =
            delta->deleted_request_headers.begin();
        key != delta->deleted_request_headers.end();
        ++key) {
     deleted_headers->AppendString(*key);
   }
-  dict->Set("deleted_headers", deleted_headers);
+  dict->Set("deleted_headers", std::move(deleted_headers));
   return std::move(dict);
 }
 
 bool InDecreasingExtensionInstallationTimeOrder(
     const linked_ptr<EventResponseDelta>& a,
     const linked_ptr<EventResponseDelta>& b) {
   return a->extension_install_time > b->extension_install_time;
 }
 
-base::ListValue* StringToCharList(const std::string& s) {
-  base::ListValue* result = new base::ListValue;
+std::unique_ptr<base::ListValue> StringToCharList(const std::string& s) {
+  auto result = base::MakeUnique<base::ListValue>();
   for (size_t i = 0, n = s.size(); i < n; ++i) {
     result->AppendInteger(*reinterpret_cast<const unsigned char*>(&s[i]));
   }
   return result;
 }
 
 bool CharListToString(const base::ListValue* list, std::string* out) {
   if (!list)
     return false;
   const size_t list_length = list->GetSize();
@@ skipping 936 matching lines @@
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                      base::Bind(&ClearCacheOnNavigationOnUI));
   }
 }
 
 // Converts the |name|, |value| pair of a http header to a HttpHeaders
 // dictionary.
 std::unique_ptr<base::DictionaryValue> CreateHeaderDictionary(
     const std::string& name,
     const std::string& value) {
-  std::unique_ptr<base::DictionaryValue> header(new base::DictionaryValue());
+  auto header = base::MakeUnique<base::DictionaryValue>();
   header->SetString(keys::kHeaderNameKey, name);
   if (base::IsStringUTF8(value)) {
     header->SetString(keys::kHeaderValueKey, value);
   } else {
     header->Set(keys::kHeaderBinaryValueKey,
                 StringToCharList(value));
   }
   return header;
 }
 
 }  // namespace extension_web_request_api_helpers