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

chrome/browser/extensions/api/tabs/tabs_event_router.cc

 // Copyright 2013 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/tabs/tabs_event_router.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 31 matching lines @@
 bool WillDispatchTabUpdatedEvent(
     WebContents* contents,
     const std::set<std::string> changed_property_names,
     content::BrowserContext* context,
     const Extension* extension,
     Event* event,
     const base::DictionaryValue* listener_filter) {
   std::unique_ptr<api::tabs::Tab> tab_object =
       ExtensionTabUtil::CreateTabObject(contents, extension);
 
-  base::DictionaryValue* tab_value = tab_object->ToValue().release();
+  std::unique_ptr<base::DictionaryValue> tab_value = tab_object->ToValue();
 
-  std::unique_ptr<base::DictionaryValue> changed_properties(
-      new base::DictionaryValue);
+  auto changed_properties = base::MakeUnique<base::DictionaryValue>();
   const base::Value* value = nullptr;
   for (const auto& property : changed_property_names) {
     if (tab_value->Get(property, &value))
-      changed_properties->Set(property, base::WrapUnique(value->DeepCopy()));
+      changed_properties->Set(property, value->CreateDeepCopy());
   }
 
-  event->event_args->Set(1, changed_properties.release());
-  event->event_args->Set(2, tab_value);
+  event->event_args->Set(1, std::move(changed_properties));
+  event->event_args->Set(2, std::move(tab_value));
   return true;
 }
 
 }  // namespace
 
 TabsEventRouter::TabEntry::TabEntry(TabsEventRouter* router,
                                     content::WebContents* contents)
     : WebContentsObserver(contents),
       complete_waiting_on_load_(false),
       was_audible_(contents->WasRecentlyAudible()),
@@ skipping 155 matching lines @@
       TabCreatedAt(contents, index, active);
     return;
   }
 
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->AppendInteger(tab_id);
 
   std::unique_ptr<base::DictionaryValue> object_args(
       new base::DictionaryValue());
-  object_args->Set(tabs_constants::kNewWindowIdKey,
-                   new Value(ExtensionTabUtil::GetWindowIdOfTab(contents)));
-  object_args->Set(tabs_constants::kNewPositionKey, new Value(index));
+  object_args->Set(
+      tabs_constants::kNewWindowIdKey,
+      base::MakeUnique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
+  object_args->Set(tabs_constants::kNewPositionKey,
+                   base::MakeUnique<Value>(index));
   args->Append(std::move(object_args));
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_ATTACHED, tabs::OnAttached::kEventName,
                 std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabDetachedAt(WebContents* contents, int index) {
   if (!GetTabEntry(contents)) {
     // The tab was removed. Don't send detach event.
     return;
   }
 
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 
   std::unique_ptr<base::DictionaryValue> object_args(
       new base::DictionaryValue());
-  object_args->Set(tabs_constants::kOldWindowIdKey,
-                   new Value(ExtensionTabUtil::GetWindowIdOfTab(contents)));
-  object_args->Set(tabs_constants::kOldPositionKey, new Value(index));
+  object_args->Set(
+      tabs_constants::kOldWindowIdKey,
+      base::MakeUnique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
+  object_args->Set(tabs_constants::kOldPositionKey,
+                   base::MakeUnique<Value>(index));
   args->Append(std::move(object_args));
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_DETACHED, tabs::OnDetached::kEventName,
                 std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabClosingAt(TabStripModel* tab_strip_model,
                                    WebContents* contents,
                                    int index) {
@@ skipping 20 matching lines @@
 void TabsEventRouter::ActiveTabChanged(WebContents* old_contents,
                                        WebContents* new_contents,
                                        int index,
                                        int reason) {
   auto args = base::MakeUnique<base::ListValue>();
   int tab_id = ExtensionTabUtil::GetTabId(new_contents);
   args->AppendInteger(tab_id);
 
   auto object_args = base::MakeUnique<base::DictionaryValue>();
   object_args->Set(tabs_constants::kWindowIdKey,
-                   new Value(ExtensionTabUtil::GetWindowIdOfTab(new_contents)));
+                   base::MakeUnique<Value>(
+                       ExtensionTabUtil::GetWindowIdOfTab(new_contents)));
   args->Append(object_args->CreateDeepCopy());
 
   // The onActivated event replaced onActiveChanged and onSelectionChanged. The
   // deprecated events take two arguments: tabId, {windowId}.
   Profile* profile =
       Profile::FromBrowserContext(new_contents->GetBrowserContext());
   EventRouter::UserGestureState gesture =
       reason & CHANGE_REASON_USER_GESTURE
       ? EventRouter::USER_GESTURE_ENABLED
       : EventRouter::USER_GESTURE_NOT_ENABLED;
   DispatchEvent(profile, events::TABS_ON_SELECTION_CHANGED,
                 tabs::OnSelectionChanged::kEventName, args->CreateDeepCopy(),
                 gesture);
   DispatchEvent(profile, events::TABS_ON_ACTIVE_CHANGED,
                 tabs::OnActiveChanged::kEventName, std::move(args), gesture);
 
   // The onActivated event takes one argument: {windowId, tabId}.
   auto on_activated_args = base::MakeUnique<base::ListValue>();
-  object_args->Set(tabs_constants::kTabIdKey, new Value(tab_id));
+  object_args->Set(tabs_constants::kTabIdKey, base::MakeUnique<Value>(tab_id));
   on_activated_args->Append(std::move(object_args));
   DispatchEvent(profile, events::TABS_ON_ACTIVATED,
                 tabs::OnActivated::kEventName, std::move(on_activated_args),
                 gesture);
 }
 
 void TabsEventRouter::TabSelectionChanged(
     TabStripModel* tab_strip_model,
     const ui::ListSelectionModel& old_model) {
   ui::ListSelectionModel::SelectedIndices new_selection =
       tab_strip_model->selection_model().selected_indices();
   std::unique_ptr<base::ListValue> all_tabs(new base::ListValue);
 
   for (size_t i = 0; i < new_selection.size(); ++i) {
     int index = new_selection[i];
     WebContents* contents = tab_strip_model->GetWebContentsAt(index);
     if (!contents)
       break;
     int tab_id = ExtensionTabUtil::GetTabId(contents);
     all_tabs->AppendInteger(tab_id);
   }
 
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   std::unique_ptr<base::DictionaryValue> select_info(new base::DictionaryValue);
 
   select_info->Set(
       tabs_constants::kWindowIdKey,
-      new Value(ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
+      base::MakeUnique<Value>(
+          ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
 
   select_info->Set(tabs_constants::kTabIdsKey, all_tabs.release());
   args->Append(std::move(select_info));
 
   // The onHighlighted event replaced onHighlightChanged.
   Profile* profile = tab_strip_model->profile();
   DispatchEvent(profile, events::TABS_ON_HIGHLIGHT_CHANGED,
                 tabs::OnHighlightChanged::kEventName,
                 std::unique_ptr<base::ListValue>(args->DeepCopy()),
                 EventRouter::USER_GESTURE_UNKNOWN);
   DispatchEvent(profile, events::TABS_ON_HIGHLIGHTED,
                 tabs::OnHighlighted::kEventName, std::move(args),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabMoved(WebContents* contents,
                                int from_index,
                                int to_index) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 
   std::unique_ptr<base::DictionaryValue> object_args(
       new base::DictionaryValue());
-  object_args->Set(tabs_constants::kWindowIdKey,
-                   new Value(ExtensionTabUtil::GetWindowIdOfTab(contents)));
-  object_args->Set(tabs_constants::kFromIndexKey, new Value(from_index));
-  object_args->Set(tabs_constants::kToIndexKey, new Value(to_index));
+  object_args->Set(
+      tabs_constants::kWindowIdKey,
+      base::MakeUnique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
+  object_args->Set(tabs_constants::kFromIndexKey,
+                   base::MakeUnique<Value>(from_index));
+  object_args->Set(tabs_constants::kToIndexKey,
+                   base::MakeUnique<Value>(to_index));
   args->Append(std::move(object_args));
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::TABS_ON_MOVED, tabs::OnMoved::kEventName,
                 std::move(args), EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void TabsEventRouter::TabUpdated(TabEntry* entry,
                                  std::set<std::string> changed_property_names) {
   bool audible = entry->web_contents()->WasRecentlyAudible();
@@ skipping 163 matching lines @@
 }
 
 void TabsEventRouter::OnAutoDiscardableStateChange(WebContents* contents,
                                                    bool is_auto_discardable) {
   std::set<std::string> changed_property_names;
   changed_property_names.insert(tabs_constants::kAutoDiscardableKey);
   DispatchTabUpdatedEvent(contents, std::move(changed_property_names));
 }
 
 }  // namespace extensions