Remove use of deprecated base::ListValue::Append(Value*) overload in extensions.

chrome/browser/extensions/menu_manager.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 "chrome/browser/extensions/menu_manager.h"
 
 #include <algorithm>
+#include <memory>
 #include <tuple>
 #include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/menu_manager_factory.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/chrome_web_view_internal.h"
@@ skipping 59 matching lines @@
       continue;
     MenuItem* item = MenuItem::Populate(
         extension_id, *dict, NULL);
     if (!item)
       continue;
     items.push_back(item);
   }
   return items;
 }
 
-std::unique_ptr<base::Value> MenuItemsToValue(const MenuItem::List& items) {
+std::unique_ptr<base::ListValue> MenuItemsToValue(const MenuItem::List& items) {
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < items.size(); ++i)
     list->Append(items[i]->ToValue());
-  return std::unique_ptr<base::Value>(list.release());
+  return list;
 }
 
 bool GetStringList(const base::DictionaryValue& dict,
                    const std::string& key,
                    std::vector<std::string>* out) {
   if (!dict.HasKey(key))
     return true;
 
   const base::ListValue* list = NULL;
   if (!dict.GetListWithoutPathExpansion(key, &list))
@@ skipping 524 matching lines @@
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
   const Extension* extension =
       registry->enabled_extensions().GetByID(item->extension_id());
 
   if (item->type() == MenuItem::RADIO)
     RadioItemSelected(item);
 
   std::unique_ptr<base::ListValue> args(new base::ListValue());
 
-  base::DictionaryValue* properties = new base::DictionaryValue();
-  SetIdKeyValue(properties, "menuItemId", item->id());
+  std::unique_ptr<base::DictionaryValue> properties(
+      new base::DictionaryValue());
+  SetIdKeyValue(properties.get(), "menuItemId", item->id());
   if (item->parent_id())
-    SetIdKeyValue(properties, "parentMenuItemId", *item->parent_id());
+    SetIdKeyValue(properties.get(), "parentMenuItemId", *item->parent_id());
 
   switch (params.media_type) {
     case blink::WebContextMenuData::MediaTypeImage:
       properties->SetString("mediaType", "image");
       break;
     case blink::WebContextMenuData::MediaTypeVideo:
       properties->SetString("mediaType", "video");
       break;
     case blink::WebContextMenuData::MediaTypeAudio:
       properties->SetString("mediaType", "audio");
       break;
     default:  {}  // Do nothing.
   }
 
-  AddURLProperty(properties, "linkUrl", params.unfiltered_link_url);
-  AddURLProperty(properties, "srcUrl", params.src_url);
-  AddURLProperty(properties, "pageUrl", params.page_url);
-  AddURLProperty(properties, "frameUrl", params.frame_url);
+  AddURLProperty(properties.get(), "linkUrl", params.unfiltered_link_url);
+  AddURLProperty(properties.get(), "srcUrl", params.src_url);
+  AddURLProperty(properties.get(), "pageUrl", params.page_url);
+  AddURLProperty(properties.get(), "frameUrl", params.frame_url);
 
   if (params.selection_text.length() > 0)
     properties->SetString("selectionText", params.selection_text);
 
   properties->SetBoolean("editable", params.is_editable);
 
   WebViewGuest* webview_guest = WebViewGuest::FromWebContents(web_contents);
   if (webview_guest) {
     // This is used in web_view_internalcustom_bindings.js.
     // The property is not exposed to developer API.
     properties->SetInteger("webviewInstanceId",
                            webview_guest->view_instance_id());
   }
 
-  args->Append(properties);
+  base::DictionaryValue* raw_properties = properties.get();
+  args->Append(std::move(properties));
 
   // Add the tab info to the argument list.
   // No tab info in a platform app.
   if (!extension || !extension->is_platform_app()) {
     // Note: web_contents are NULL in unit tests :(
     if (web_contents) {
       int frame_id = ExtensionApiFrameIdMap::GetFrameId(render_frame_host);
       if (frame_id != ExtensionApiFrameIdMap::kInvalidFrameId)
-        properties->SetInteger("frameId", frame_id);
+        raw_properties->SetInteger("frameId", frame_id);
 
       args->Append(ExtensionTabUtil::CreateTabObject(web_contents)->ToValue());
     } else {
-      args->Append(new base::DictionaryValue());
+      args->Append(base::MakeUnique<base::DictionaryValue>());
     }
   }
 
   if (item->type() == MenuItem::CHECKBOX ||
       item->type() == MenuItem::RADIO) {
     bool was_checked = item->checked();
-    properties->SetBoolean("wasChecked", was_checked);
+    raw_properties->SetBoolean("wasChecked", was_checked);
 
     // RADIO items always get set to true when you click on them, but CHECKBOX
     // items get their state toggled.
     bool checked =
         (item->type() == MenuItem::RADIO) ? true : !was_checked;
 
     item->SetChecked(checked);
-    properties->SetBoolean("checked", item->checked());
+    raw_properties->SetBoolean("checked", item->checked());
 
     if (extension)
       WriteToStorage(extension, item->id().extension_key);
   }
 
   // Note: web_contents are NULL in unit tests :(
   if (web_contents && TabHelper::FromWebContents(web_contents)) {
     TabHelper::FromWebContents(web_contents)
         ->active_tab_permission_granter()
         ->GrantIfRequested(extension);
@@ skipping 269 matching lines @@
 bool MenuItem::Id::operator!=(const Id& other) const {
   return !(*this == other);
 }
 
 bool MenuItem::Id::operator<(const Id& other) const {
   return std::tie(incognito, extension_key, uid, string_uid) <
     std::tie(other.incognito, other.extension_key, other.uid, other.string_uid);
 }
 
 }  // namespace extensions