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

chrome/browser/extensions/api/downloads/downloads_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/downloads/downloads_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <set>
@@ skipping 1591 matching lines @@
     const FilenameChangedCallback& change) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ExtensionDownloadsEventRouterData* data =
       ExtensionDownloadsEventRouterData::Get(item);
   if (!data) {
     no_change.Run();
     return;
   }
   data->BeginFilenameDetermination(no_change, change);
   bool any_determiners = false;
-  base::DictionaryValue* json = DownloadItemToJSON(
-      item, profile_).release();
+  std::unique_ptr<base::DictionaryValue> json =
+      DownloadItemToJSON(item, profile_);
   json->SetString(kFilenameKey, suggested_path.LossyDisplayName());
   DispatchEvent(events::DOWNLOADS_ON_DETERMINING_FILENAME,
                 downloads::OnDeterminingFilename::kEventName, false,
                 base::Bind(&OnDeterminingFilenameWillDispatchCallback,
                            &any_determiners, data),
-                json);
+                std::move(json));
   if (!any_determiners) {
     data->ClearPendingDeterminers();
     if (!data->creator_suggested_filename().empty() ||
         (data->creator_conflict_action() !=
          downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY)) {
       change.Run(data->creator_suggested_filename(),
                  ConvertConflictAction(data->creator_conflict_action()));
       // If all listeners are removed, don't keep |data| around.
       data->ResetCreatorSuggestion();
     } else {
@@ skipping 140 matching lines @@
   if (!router ||
       (!router->HasEventListener(downloads::OnCreated::kEventName) &&
        !router->HasEventListener(downloads::OnChanged::kEventName) &&
        !router->HasEventListener(
             downloads::OnDeterminingFilename::kEventName))) {
     return;
   }
   std::unique_ptr<base::DictionaryValue> json_item(
       DownloadItemToJSON(download_item, profile_));
   DispatchEvent(events::DOWNLOADS_ON_CREATED, downloads::OnCreated::kEventName,
-                true, Event::WillDispatchCallback(), json_item->DeepCopy());
+                true, Event::WillDispatchCallback(),
+                json_item->CreateDeepCopy());
   if (!ExtensionDownloadsEventRouterData::Get(download_item) &&
       (router->HasEventListener(downloads::OnChanged::kEventName) ||
        router->HasEventListener(
            downloads::OnDeterminingFilename::kEventName))) {
     new ExtensionDownloadsEventRouterData(download_item, std::move(json_item));
   }
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadUpdated(
     DownloadManager* manager, DownloadItem* download_item) {
@@ skipping 50 matching lines @@
       changed = true;
     }
   }
 
   // Update the OnChangedStat and dispatch the event if something significant
   // changed. Replace the stored json with the new json.
   data->OnItemUpdated();
   if (changed) {
     DispatchEvent(events::DOWNLOADS_ON_CHANGED,
                   downloads::OnChanged::kEventName, true,
-                  Event::WillDispatchCallback(), delta.release());
+                  Event::WillDispatchCallback(), std::move(delta));
     data->OnChangedFired();
   }
   data->set_json(std::move(new_json));
 }
 
 void ExtensionDownloadsEventRouter::OnDownloadRemoved(
     DownloadManager* manager, DownloadItem* download_item) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (download_item->IsTemporary())
     return;
-  DispatchEvent(
-      events::DOWNLOADS_ON_ERASED, downloads::OnErased::kEventName, true,
-      Event::WillDispatchCallback(),
-      new base::FundamentalValue(static_cast<int>(download_item->GetId())));
+  DispatchEvent(events::DOWNLOADS_ON_ERASED, downloads::OnErased::kEventName,
+                true, Event::WillDispatchCallback(),
+                base::MakeUnique<base::FundamentalValue>(
+                    static_cast<int>(download_item->GetId())));
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
     events::HistogramValue histogram_value,
     const std::string& event_name,
     bool include_incognito,
     const Event::WillDispatchCallback& will_dispatch_callback,
-    base::Value* arg) {
+    std::unique_ptr<base::Value> arg) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!EventRouter::Get(profile_))
     return;
   std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Append(arg);
+  args->Append(std::move(arg));
   std::string json_args;
   base::JSONWriter::Write(*args, &json_args);
   std::unique_ptr<Event> event(
       new Event(histogram_value, event_name, std::move(args)));
   // The downloads system wants to share on-record events with off-record
   // extension renderers even in incognito_split_mode because that's how
   // chrome://downloads works. The "restrict_to_profile" mechanism does not
   // anticipate this, so it does not automatically prevent sharing off-record
   // events with on-record extension renderers.
   event->restrict_to_browser_context =
@@ skipping 29 matching lines @@
     return;
   base::Time now(base::Time::Now());
   int delta = now.ToTimeT() - last_checked_removal_.ToTimeT();
   if (delta <= kFileExistenceRateLimitSeconds)
     return;
   last_checked_removal_ = now;
   manager->CheckForHistoryFilesRemoval();
 }
 
 }  // namespace extensions