Rewrite simple uses of base::ListValue::Append() taking a raw pointer var.

chrome/browser/ui/webui/signin/signin_supervised_user_import_handler.cc

 // Copyright 2016 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/ui/webui/signin/signin_supervised_user_import_handler.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <set>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
@@ skipping 229 matching lines @@
   base::ListValue supervised_users;
   SupervisedUserSharedSettingsService* service =
       SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(profile);
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* value = NULL;
     bool success = it.value().GetAsDictionary(&value);
     DCHECK(success);
     std::string name;
     value->GetString(SupervisedUserSyncService::kName, &name);
 
-    base::DictionaryValue* supervised_user = new base::DictionaryValue;
+    std::unique_ptr<base::DictionaryValue> supervised_user(
+        new base::DictionaryValue);
     supervised_user->SetString("id", it.key());
     supervised_user->SetString("name", name);
 
     int avatar_index = SupervisedUserSyncService::kNoAvatar;
     const base::Value* avatar_index_value =
         service->GetValue(it.key(), supervised_users::kChromeAvatarIndex);
     if (avatar_index_value) {
       success = avatar_index_value->GetAsInteger(&avatar_index);
     } else {
       // Check if there is a legacy avatar index stored.
       std::string avatar_str;
       value->GetString(SupervisedUserSyncService::kChromeAvatar, &avatar_str);
       success =
           SupervisedUserSyncService::GetAvatarIndex(avatar_str, &avatar_index);
     }
     DCHECK(success);
 
     std::string avatar_url =
         avatar_index == SupervisedUserSyncService::kNoAvatar ?
             profiles::GetDefaultAvatarIconUrl(
                 profiles::GetPlaceholderAvatarIndex()) :
             profiles::GetDefaultAvatarIconUrl(avatar_index);
     supervised_user->SetString("iconURL", avatar_url);
     bool on_current_device =
         supervised_user_ids.find(it.key()) != supervised_user_ids.end();
     supervised_user->SetBoolean("onCurrentDevice", on_current_device);
 
-    supervised_users.Append(supervised_user);
+    supervised_users.Append(std::move(supervised_user));
   }
 
   // Resolve callback with response.
   ResolveJavascriptCallback(
       base::StringValue(webui_callback_id_),
       supervised_users);
   webui_callback_id_.clear();
 }
 
 bool SigninSupervisedUserImportHandler::IsAccountConnected(
       Profile* profile) const {
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   return signin_manager && signin_manager->IsAuthenticated();
 }
 
 bool SigninSupervisedUserImportHandler::HasAuthError(Profile* profile) const {
   SigninErrorController* error_controller =
       SigninErrorControllerFactory::GetForProfile(profile);
   if (!error_controller)
     return true;
 
   GoogleServiceAuthError::State state = error_controller->auth_error().state();
   return state != GoogleServiceAuthError::NONE;
 }