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

extensions/browser/api/web_request/web_request_api.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.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 1601 matching lines @@
     case ExtensionWebRequestEventRouter::kOnAuthRequired:
       return helpers::CalculateOnAuthRequiredDelta(
           response->extension_id, response->extension_install_time,
           response->cancel, &response->auth_credentials);
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
-base::Value* SerializeResponseHeaders(const helpers::ResponseHeaders& headers) {
-  std::unique_ptr<base::ListValue> serialized_headers(new base::ListValue());
+std::unique_ptr<base::Value> SerializeResponseHeaders(
+    const helpers::ResponseHeaders& headers) {
+  auto serialized_headers = base::MakeUnique<base::ListValue>();
   for (const auto& it : headers) {
     serialized_headers->Append(
         helpers::CreateHeaderDictionary(it.first, it.second));
   }
-  return serialized_headers.release();
+  return std::move(serialized_headers);

[Devlin, 2017/06/02 15:38:48]

we shouldn't need std::move() here, I'd think?  Or does the compiler require it
since serialized_headers is a ListValue instead of a Value?

[vabr (Chromium), 2017/06/03 11:14:52]

Until C++14 we need move because of the upcast. See
https://groups.google.com/a/chromium.org/d/msg/cxx/gfV_Srujt6A/OvJ1bo4hBgAJ.

Actually, in this particular case, the need for move will disappear once
ListValue gets merged into Value (which is what jdoerrie@ is actively working
on).

 }
 
 // Convert a RequestCookieModifications/ResponseCookieModifications object to a
 // base::ListValue which summarizes the changes made.  This is templated since
 // the two types (request/response) are different but contain essentially the
 // same fields.
 template <typename CookieType>
-base::ListValue* SummarizeCookieModifications(
+std::unique_ptr<base::ListValue> SummarizeCookieModifications(
     const std::vector<linked_ptr<CookieType>>& modifications) {
-  std::unique_ptr<base::ListValue> cookie_modifications(new base::ListValue());
+  auto cookie_modifications = base::MakeUnique<base::ListValue>();
   for (const auto& it : modifications) {
-    std::unique_ptr<base::DictionaryValue> summary(new base::DictionaryValue());
+    auto summary = base::MakeUnique<base::DictionaryValue>();
     const CookieType& mod = *(it.get());
     switch (mod.type) {
       case helpers::ADD:
         summary->SetString(activity_log::kCookieModificationTypeKey,
                            activity_log::kCookieModificationAdd);
         break;
       case helpers::EDIT:
         summary->SetString(activity_log::kCookieModificationTypeKey,
                            activity_log::kCookieModificationEdit);
         break;
@@ skipping 17 matching lines @@
         summary->SetString(activity_log::kCookieModDomainKey,
                            *mod.modification->name);
       }
       if (mod.modification->domain) {
         summary->SetString(activity_log::kCookieModDomainKey,
                            *mod.modification->name);
       }
     }
     cookie_modifications->Append(std::move(summary));
   }
-  return cookie_modifications.release();
+  return cookie_modifications;
 }
 
 // Converts an EventResponseDelta object to a dictionary value suitable for the
 // activity log.
 std::unique_ptr<base::DictionaryValue> SummarizeResponseDelta(
     const std::string& event_name,
     const helpers::EventResponseDelta& delta) {
   std::unique_ptr<base::DictionaryValue> details(new base::DictionaryValue());
   if (delta.cancel)
     details->SetBoolean(activity_log::kCancelKey, true);
   if (!delta.new_url.is_empty())
     details->SetString(activity_log::kNewUrlKey, delta.new_url.spec());
 
   std::unique_ptr<base::ListValue> modified_headers(new base::ListValue());
   net::HttpRequestHeaders::Iterator iter(delta.modified_request_headers);
   while (iter.GetNext()) {
     modified_headers->Append(
         helpers::CreateHeaderDictionary(iter.name(), iter.value()));
   }
   if (!modified_headers->empty()) {
     details->Set(activity_log::kModifiedRequestHeadersKey,
-                 modified_headers.release());
+                 std::move(modified_headers));
   }
 
   std::unique_ptr<base::ListValue> deleted_headers(new base::ListValue());
   deleted_headers->AppendStrings(delta.deleted_request_headers);
   if (!deleted_headers->empty()) {
     details->Set(activity_log::kDeletedRequestHeadersKey,
-                 deleted_headers.release());
+                 std::move(deleted_headers));
   }
 
   if (!delta.added_response_headers.empty()) {
     details->Set(activity_log::kAddedRequestHeadersKey,
                  SerializeResponseHeaders(delta.added_response_headers));
   }
   if (!delta.deleted_response_headers.empty()) {
     details->Set(activity_log::kDeletedResponseHeadersKey,
                  SerializeResponseHeaders(delta.deleted_response_headers));
   }
@@ skipping 726 matching lines @@
   // Since EventListeners are segmented by browser_context, check that
   // last, as it is exceedingly unlikely to be different.
   return extension_id == that.extension_id &&
          sub_event_name == that.sub_event_name &&
          web_view_instance_id == that.web_view_instance_id &&
          embedder_process_id == that.embedder_process_id &&
          browser_context == that.browser_context;
 }
 
 }  // namespace extensions