Reland: Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/autotest_private/autotest_private_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 "chrome/browser/extensions/api/autotest_private/autotest_private_api.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/autotest_private.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
@@ skipping 10 matching lines @@
 #include "chromeos/dbus/session_manager_client.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #endif
 
 namespace extensions {
 namespace {
 
-base::ListValue* GetHostPermissions(const Extension* ext, bool effective_perm) {
+std::unique_ptr<base::ListValue> GetHostPermissions(const Extension* ext,
+                                                    bool effective_perm) {
   const PermissionsData* permissions_data = ext->permissions_data();
   const URLPatternSet& pattern_set =
       effective_perm ? permissions_data->GetEffectiveHostPermissions()
                      : permissions_data->active_permissions().explicit_hosts();
 
-  base::ListValue* permissions = new base::ListValue;
+  auto permissions = base::MakeUnique<base::ListValue>();
   for (URLPatternSet::const_iterator perm = pattern_set.begin();
        perm != pattern_set.end();
        ++perm) {
     permissions->AppendString(perm->GetAsString());
   }
 
   return permissions;
 }
 
-base::ListValue* GetAPIPermissions(const Extension* ext) {
-  base::ListValue* permissions = new base::ListValue;
+std::unique_ptr<base::ListValue> GetAPIPermissions(const Extension* ext) {
+  auto permissions = base::MakeUnique<base::ListValue>();
   std::set<std::string> perm_list =
       ext->permissions_data()->active_permissions().GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
        perm != perm_list.end(); ++perm) {
     permissions->AppendString(*perm);
   }
   return permissions;
 }
 
 bool IsTestMode(content::BrowserContext* context) {
@@ skipping 88 matching lines @@
   DVLOG(1) << "AutotestPrivateGetExtensionsInfoFunction";
 
   ExtensionService* service =
       ExtensionSystem::Get(browser_context())->extension_service();
   ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context());
   const ExtensionSet& extensions = registry->enabled_extensions();
   const ExtensionSet& disabled_extensions = registry->disabled_extensions();
   ExtensionActionManager* extension_action_manager =
       ExtensionActionManager::Get(browser_context());
 
-  base::ListValue* extensions_values = new base::ListValue;
+  auto extensions_values = base::MakeUnique<base::ListValue>();
   ExtensionList all;
   all.insert(all.end(), extensions.begin(), extensions.end());
   all.insert(all.end(), disabled_extensions.begin(), disabled_extensions.end());
   for (ExtensionList::const_iterator it = all.begin();
        it != all.end(); ++it) {
     const Extension* extension = it->get();
     std::string id = extension->id();
     std::unique_ptr<base::DictionaryValue> extension_value(
         new base::DictionaryValue);
     extension_value->SetString("id", id);
@@ skipping 25 matching lines @@
         "allowedInIncognito", util::IsIncognitoEnabled(id, browser_context()));
     extension_value->SetBoolean(
         "hasPageAction",
         extension_action_manager->GetPageAction(*extension) != NULL);
 
     extensions_values->Append(std::move(extension_value));
   }
 
   std::unique_ptr<base::DictionaryValue> return_value(
       new base::DictionaryValue);
-  return_value->Set("extensions", extensions_values);
+  return_value->Set("extensions", std::move(extensions_values));
   return RespondNow(OneArgument(std::move(return_value)));
 }
 
 static int AccessArray(const volatile int arr[], const volatile int *index) {
   return arr[*index];
 }
 
 ExtensionFunction::ResponseAction
 AutotestPrivateSimulateAsanMemoryBugFunction::Run() {
   DVLOG(1) << "AutotestPrivateSimulateAsanMemoryBugFunction";
@@ skipping 168 matching lines @@
   return new AutotestPrivateAPI();
 }
 
 AutotestPrivateAPI::AutotestPrivateAPI() : test_mode_(false) {
 }
 
 AutotestPrivateAPI::~AutotestPrivateAPI() {
 }
 
 }  // namespace extensions