Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/external_pref_loader.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/external_pref_loader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 42 matching lines @@
   } while (true);
 
   return external_extension_paths;
 }
 
 // Extracts extension information from a json file serialized by |serializer|.
 // |path| is only used for informational purposes (outputted when an error
 // occurs). An empty dictionary is returned in case of failure (e.g. invalid
 // path or json content).
 // Caller takes ownership of the returned dictionary.
-scoped_ptr<base::DictionaryValue> ExtractExtensionPrefs(
+std::unique_ptr<base::DictionaryValue> ExtractExtensionPrefs(
     base::ValueDeserializer* deserializer,
     const base::FilePath& path) {
   std::string error_msg;
-  scoped_ptr<base::Value> extensions =
+  std::unique_ptr<base::Value> extensions =
       deserializer->Deserialize(NULL, &error_msg);
   if (!extensions) {
     LOG(WARNING) << "Unable to deserialize json data: " << error_msg
                  << " in file " << path.value() << ".";
-    return make_scoped_ptr(new base::DictionaryValue);
+    return base::WrapUnique(new base::DictionaryValue);
   }
 
-  scoped_ptr<base::DictionaryValue> ext_dictionary =
+  std::unique_ptr<base::DictionaryValue> ext_dictionary =
       base::DictionaryValue::From(std::move(extensions));
   if (ext_dictionary) {
     return ext_dictionary;
   }
 
   LOG(WARNING) << "Expected a JSON dictionary in file " << path.value()
                  << ".";
-  return make_scoped_ptr(new base::DictionaryValue);
-
+  return base::WrapUnique(new base::DictionaryValue);
 }
 
 }  // namespace
 
 namespace extensions {
 
 ExternalPrefLoader::ExternalPrefLoader(int base_path_id,
                                        Options options,
                                        Profile* profile)
     : base_path_id_(base_path_id),
@@ skipping 80 matching lines @@
   service->RemoveObserver(this);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ExternalPrefLoader::LoadOnFileThread, this));
 }
 
 void ExternalPrefLoader::LoadOnFileThread() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
 
   // TODO(skerner): Some values of base_path_id_ will cause
   // PathService::Get() to return false, because the path does
   // not exist.  Find and fix the build/install scripts so that
   // this can become a CHECK().  Known examples include chrome
   // OS developer builds and linux install packages.
   // Tracked as crbug.com/70402 .
   if (PathService::Get(base_path_id_, &base_path_)) {
     ReadExternalExtensionPrefFile(prefs.get());
 
@@ skipping 49 matching lines @@
     }
 #else
     // The only platform that uses this check is Mac OS.  If you add one,
     // you need to implement base::VerifyPathControlledByAdmin() for
     // that platform.
     NOTREACHED();
 #endif  // defined(OS_MACOSX)
   }
 
   JSONFileValueDeserializer deserializer(json_file);
-  scoped_ptr<base::DictionaryValue> ext_prefs =
+  std::unique_ptr<base::DictionaryValue> ext_prefs =
       ExtractExtensionPrefs(&deserializer, json_file);
   if (ext_prefs)
     prefs->MergeDictionary(ext_prefs.get());
 }
 
 void ExternalPrefLoader::ReadStandaloneExtensionPrefFiles(
     base::DictionaryValue* prefs) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   CHECK(NULL != prefs);
 
@@ skipping 17 matching lines @@
         base::UTF16ToASCII(
             extension_candidate_path.RemoveExtension().BaseName().value());
 #elif defined(OS_POSIX)
         extension_candidate_path.RemoveExtension().BaseName().value();
 #endif
 
     DVLOG(1) << "Reading json file: "
              << extension_candidate_path.LossyDisplayName();
 
     JSONFileValueDeserializer deserializer(extension_candidate_path);
-    scoped_ptr<base::DictionaryValue> ext_prefs =
+    std::unique_ptr<base::DictionaryValue> ext_prefs =
         ExtractExtensionPrefs(&deserializer, extension_candidate_path);
     if (ext_prefs) {
       DVLOG(1) << "Adding extension with id: " << id;
       prefs->Set(id, ext_prefs.release());
     }
   }
 }
 
 ExternalTestingLoader::ExternalTestingLoader(
     const std::string& json_data,
@@ skipping 11 matching lines @@
   LoadFinished();
 }
 
 ExternalTestingLoader::~ExternalTestingLoader() {}
 
 const base::FilePath ExternalTestingLoader::GetBaseCrxFilePath() {
   return fake_base_path_;
 }
 
 }  // namespace extensions