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

extensions/browser/api/runtime/runtime_api.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 "extensions/browser/api/runtime/runtime_api.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 500 matching lines @@
     const std::string& extension_id,
     const base::Version& old_version,
     bool chrome_updated) {
   if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
     return;
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
   std::unique_ptr<base::ListValue> event_args(new base::ListValue());
-  base::DictionaryValue* info = new base::DictionaryValue();
-  event_args->Append(info);
+  std::unique_ptr<base::DictionaryValue> info(new base::DictionaryValue());
   if (old_version.IsValid()) {
     info->SetString(kInstallReason, kInstallReasonUpdate);
     info->SetString(kInstallPreviousVersion, old_version.GetString());
   } else if (chrome_updated) {
     info->SetString(kInstallReason, kInstallReasonChromeUpdate);
   } else {
     info->SetString(kInstallReason, kInstallReasonInstall);
   }
+  event_args->Append(std::move(info));
   EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
   std::unique_ptr<Event> event(new Event(events::RUNTIME_ON_INSTALLED,
                                          runtime::OnInstalled::kEventName,
                                          std::move(event_args)));
   event_router->DispatchEventWithLazyListener(extension_id, std::move(event));
 
   if (old_version.IsValid()) {
     const Extension* extension =
         ExtensionRegistry::Get(context)->enabled_extensions().GetByID(
             extension_id);
     if (extension && SharedModuleInfo::IsSharedModule(extension)) {
       std::unique_ptr<ExtensionSet> dependents =
           system->GetDependentExtensions(extension);
       for (ExtensionSet::const_iterator i = dependents->begin();
            i != dependents->end();
            i++) {
         std::unique_ptr<base::ListValue> sm_event_args(new base::ListValue());
-        base::DictionaryValue* sm_info = new base::DictionaryValue();
-        sm_event_args->Append(sm_info);
+        std::unique_ptr<base::DictionaryValue> sm_info(
+            new base::DictionaryValue());
         sm_info->SetString(kInstallReason, kInstallReasonSharedModuleUpdate);
         sm_info->SetString(kInstallPreviousVersion, old_version.GetString());
         sm_info->SetString(kInstallId, extension_id);
+        sm_event_args->Append(std::move(sm_info));
         std::unique_ptr<Event> sm_event(new Event(
             events::RUNTIME_ON_INSTALLED, runtime::OnInstalled::kEventName,
             std::move(sm_event_args)));
         event_router->DispatchEventWithLazyListener((*i)->id(),
                                                     std::move(sm_event));
       }
     }
   }
 }
 
 // static
 void RuntimeEventRouter::DispatchOnUpdateAvailableEvent(
     content::BrowserContext* context,
     const std::string& extension_id,
     const base::DictionaryValue* manifest) {
   ExtensionSystem* system = ExtensionSystem::Get(context);
   if (!system)
     return;
 
   std::unique_ptr<base::ListValue> args(new base::ListValue);
-  args->Append(manifest->DeepCopy());
+  args->Append(manifest->CreateDeepCopy());
   EventRouter* event_router = EventRouter::Get(context);
   DCHECK(event_router);
   std::unique_ptr<Event> event(new Event(events::RUNTIME_ON_UPDATE_AVAILABLE,
                                          runtime::OnUpdateAvailable::kEventName,
                                          std::move(args)));
   event_router->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 // static
 void RuntimeEventRouter::DispatchOnBrowserUpdateAvailableEvent(
@@ skipping 199 matching lines @@
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, filesystem_id);
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("fileSystemId", filesystem_id);
   dict->SetString("baseName", relative_path);
   return RespondNow(OneArgument(std::move(dict)));
 }
 
 }  // namespace extensions