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

chrome/browser/extensions/convert_user_script.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/convert_user_script.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/extension_user_script_loader.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/user_script.h"
 #include "url/gurl.h"
 
@@ skipping 66 matching lines @@
   // missing.
   if (!script.version().empty())
     root->SetString(keys::kVersion, script.version());
   else
     root->SetString(keys::kVersion, "1.0");
 
   root->SetString(keys::kDescription, script.description());
   root->SetString(keys::kPublicKey, key);
   root->SetBoolean(keys::kConvertedFromUserScript, true);
 
-  base::ListValue* js_files = new base::ListValue();
+  auto js_files = base::MakeUnique<base::ListValue>();
   js_files->AppendString("script.js");
 
   // If the script provides its own match patterns, we use those. Otherwise, we
   // generate some using the include globs.
-  base::ListValue* matches = new base::ListValue();
+  auto matches = base::MakeUnique<base::ListValue>();
   if (!script.url_patterns().is_empty()) {
     for (URLPatternSet::const_iterator i = script.url_patterns().begin();
          i != script.url_patterns().end(); ++i) {
       matches->AppendString(i->GetAsString());
     }
   } else {
     // TODO(aa): Derive tighter matches where possible.
     matches->AppendString("http://*/*");
     matches->AppendString("https://*/*");
   }
 
   // Read the exclude matches, if any are present.
-  base::ListValue* exclude_matches = new base::ListValue();
+  auto exclude_matches = base::MakeUnique<base::ListValue>();
   if (!script.exclude_url_patterns().is_empty()) {
     for (URLPatternSet::const_iterator i =
          script.exclude_url_patterns().begin();
          i != script.exclude_url_patterns().end(); ++i) {
       exclude_matches->AppendString(i->GetAsString());
     }
   }
 
-  base::ListValue* includes = new base::ListValue();
+  auto includes = base::MakeUnique<base::ListValue>();
   for (size_t i = 0; i < script.globs().size(); ++i)
     includes->AppendString(script.globs().at(i));
 
-  base::ListValue* excludes = new base::ListValue();
+  auto excludes = base::MakeUnique<base::ListValue>();
   for (size_t i = 0; i < script.exclude_globs().size(); ++i)
     excludes->AppendString(script.exclude_globs().at(i));
 
-  std::unique_ptr<base::DictionaryValue> content_script(
-      new base::DictionaryValue());
-  content_script->Set(keys::kMatches, matches);
-  content_script->Set(keys::kExcludeMatches, exclude_matches);
-  content_script->Set(keys::kIncludeGlobs, includes);
-  content_script->Set(keys::kExcludeGlobs, excludes);
-  content_script->Set(keys::kJs, js_files);
+  auto content_script = base::MakeUnique<base::DictionaryValue>();
+  content_script->Set(keys::kMatches, std::move(matches));
+  content_script->Set(keys::kExcludeMatches, std::move(exclude_matches));
+  content_script->Set(keys::kIncludeGlobs, std::move(includes));
+  content_script->Set(keys::kExcludeGlobs, std::move(excludes));
+  content_script->Set(keys::kJs, std::move(js_files));
 
   if (script.run_location() == UserScript::DOCUMENT_START)
     content_script->SetString(keys::kRunAt, values::kRunAtDocumentStart);
   else if (script.run_location() == UserScript::DOCUMENT_END)
     content_script->SetString(keys::kRunAt, values::kRunAtDocumentEnd);
   else if (script.run_location() == UserScript::DOCUMENT_IDLE)
     // This is the default, but store it just in case we change that.
     content_script->SetString(keys::kRunAt, values::kRunAtDocumentIdle);
 
-  base::ListValue* content_scripts = new base::ListValue();
+  auto content_scripts = base::MakeUnique<base::ListValue>();
   content_scripts->Append(std::move(content_script));
 
-  root->Set(keys::kContentScripts, content_scripts);
+  root->Set(keys::kContentScripts, std::move(content_scripts));
 
   base::FilePath manifest_path = temp_dir.GetPath().Append(kManifestFilename);
   JSONFileValueSerializer serializer(manifest_path);
   if (!serializer.Serialize(*root)) {
     *error = base::ASCIIToUTF16("Could not write JSON.");
     return NULL;
   }
 
   // Write the script file.
   if (!base::CopyFile(user_script_path,
@@ skipping 12 matching lines @@
   if (!extension.get()) {
     NOTREACHED() << "Could not init extension " << *error;
     return NULL;
   }
 
   temp_dir.Take();  // The caller takes ownership of the directory.
   return extension;
 }
 
 }  // namespace extensions