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

chrome/browser/extensions/extension_assets_manager_chromeos.cc

 // Copyright (c) 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 "chrome/browser/extensions/extension_assets_manager_chromeos.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/sequenced_task_runner.h"
 #include "base/sys_info.h"

[jdoerrie, 2017/04/06 14:25:51]

#include "base/values.h"

[vabr (Chromium), 2017/04/07 20:40:40]

Done.

 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 362 matching lines @@
                      version,
                      info.unpacked_extension_root,
                      info.local_install_dir,
                      info.callback));
     }
     return;
   }
 
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate shared_extensions(local_state, kSharedExtensions);
-  base::DictionaryValue* extension_info = NULL;
-  if (!shared_extensions->GetDictionary(id, &extension_info)) {
-    extension_info = new base::DictionaryValue;
-    shared_extensions->Set(id, extension_info);
+  base::DictionaryValue* extension_info_weak = NULL;
+  if (!shared_extensions->GetDictionary(id, &extension_info_weak)) {
+    auto extension_info = base::MakeUnique<base::DictionaryValue>();
+    extension_info_weak = extension_info.get();
+    shared_extensions->Set(id, std::move(extension_info));
   }
 
   CHECK(!shared_extensions->HasKey(version));
-  base::DictionaryValue* version_info = new base::DictionaryValue;
-  extension_info->SetWithoutPathExpansion(version, version_info);
+  auto version_info = base::MakeUnique<base::DictionaryValue>();
   version_info->SetString(kSharedExtensionPath, shared_version_dir.value());
 
-  base::ListValue* users = new base::ListValue;
-  version_info->Set(kSharedExtensionUsers, users);
+  auto users = base::MakeUnique<base::ListValue>();
   for (size_t i = 0; i < pending_installs.size(); i++) {
     ExtensionAssetsManagerHelper::PendingInstallInfo& info =
         pending_installs[i];
       users->AppendString(info.profile->GetProfileUserName());
 
     ExtensionAssetsManagerChromeOS::GetFileTaskRunner(info.profile)->PostTask(
         FROM_HERE,
         base::Bind(info.callback, shared_version_dir));
   }
+  version_info->Set(kSharedExtensionUsers, std::move(users));
+  extension_info_weak->SetWithoutPathExpansion(version,
+                                               std::move(version_info));
 }
 
 // static
 void ExtensionAssetsManagerChromeOS::InstallLocalExtension(
     const std::string& id,
     const std::string& version,
     const base::FilePath& unpacked_extension_root,
     const base::FilePath& local_install_dir,
     InstallExtensionCallback callback) {
   callback.Run(file_util::InstallExtension(
@@ skipping 139 matching lines @@
           std::make_pair(id, base::FilePath(shared_path)));
     } else {
       extension_info->RemoveWithoutPathExpansion(*it, NULL);
     }
   }
 
   return true;
 }
 
 }  // namespace extensions