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

chrome/browser/chromeos/customization/customization_document.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/chromeos/customization/customization_document.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 151 matching lines @@
 class ServicesCustomizationExternalLoader
     : public extensions::ExternalLoader,
       public base::SupportsWeakPtr<ServicesCustomizationExternalLoader> {
  public:
   explicit ServicesCustomizationExternalLoader(Profile* profile)
       : is_apps_set_(false), profile_(profile) {}
 
   Profile* profile() { return profile_; }
 
   // Used by the ServicesCustomizationDocument to update the current apps.
-  void SetCurrentApps(scoped_ptr<base::DictionaryValue> prefs) {
+  void SetCurrentApps(std::unique_ptr<base::DictionaryValue> prefs) {
     apps_.Swap(prefs.get());
     is_apps_set_ = true;
     StartLoading();
   }
 
   // Implementation of extensions::ExternalLoader:
   void StartLoading() override {
     if (!is_apps_set_) {
       ServicesCustomizationDocument::GetInstance()->StartFetching();
       // In case of missing customization ID, SetCurrentApps will be called
@@ skipping 36 matching lines @@
   std::string manifest;
   if (!base::ReadFileToString(manifest_path, &manifest))
     return false;
   return LoadManifestFromString(manifest);
 }
 
 bool CustomizationDocument::LoadManifestFromString(
     const std::string& manifest) {
   int error_code = 0;
   std::string error;
-  scoped_ptr<base::Value> root = base::JSONReader::ReadAndReturnError(
+  std::unique_ptr<base::Value> root = base::JSONReader::ReadAndReturnError(
       manifest, base::JSON_ALLOW_TRAILING_COMMAS, &error_code, &error);
   if (error_code != base::JSONReader::JSON_NO_ERROR)
     LOG(ERROR) << error;
   DCHECK(root.get() != NULL);
   if (root.get() == NULL)
     return false;
   DCHECK(root->GetType() == base::Value::TYPE_DICTIONARY);
   if (root->GetType() == base::Value::TYPE_DICTIONARY) {
     root_.reset(static_cast<base::DictionaryValue*>(root.release()));
     std::string result;
@@ skipping 352 matching lines @@
   }
 
   LogManifestLoadResult(HISTOGRAM_LOAD_RESULT_PARSING_ERROR);
   return false;
 }
 
 void ServicesCustomizationDocument::OnManifestLoaded() {
   if (!WasOOBECustomizationApplied())
     ApplyOOBECustomization();
 
-  scoped_ptr<base::DictionaryValue> prefs =
+  std::unique_ptr<base::DictionaryValue> prefs =
       GetDefaultAppsInProviderFormat(*root_);
   for (ExternalLoaders::iterator it = external_loaders_.begin();
        it != external_loaders_.end(); ++it) {
     if (*it) {
       UpdateCachedManifest((*it)->profile());
       (*it)->SetCurrentApps(
-          scoped_ptr<base::DictionaryValue>(prefs->DeepCopy()));
+          std::unique_ptr<base::DictionaryValue>(prefs->DeepCopy()));
       SetOemFolderName((*it)->profile(), *root_);
     }
   }
 }
 
 void ServicesCustomizationDocument::OnURLFetchComplete(
     const net::URLFetcher* source) {
   std::string mime_type;
   std::string data;
   if (source->GetStatus().is_success() &&
@@ skipping 41 matching lines @@
     return false;
 
   std::string url;
   if (!root_->GetString(kDefaultWallpaperAttr, &url))
     return false;
 
   *out_url = GURL(url);
   return true;
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ServicesCustomizationDocument::GetDefaultApps() const {
   if (!IsReady())
-    return scoped_ptr<base::DictionaryValue>();
+    return std::unique_ptr<base::DictionaryValue>();
 
   return GetDefaultAppsInProviderFormat(*root_);
 }
 
 std::string ServicesCustomizationDocument::GetOemAppsFolderName(
     const std::string& locale) const {
   if (!IsReady())
     return std::string();
 
   return GetOemAppsFolderNameImpl(locale, *root_);
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ServicesCustomizationDocument::GetDefaultAppsInProviderFormat(
     const base::DictionaryValue& root) {
-  scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> prefs(new base::DictionaryValue);
   const base::ListValue* apps_list = NULL;
   if (root.GetList(kDefaultAppsAttr, &apps_list)) {
     for (size_t i = 0; i < apps_list->GetSize(); ++i) {
       std::string app_id;
       const base::DictionaryValue* app_entry = nullptr;
-      scoped_ptr<base::DictionaryValue> entry;
+      std::unique_ptr<base::DictionaryValue> entry;
       if (apps_list->GetString(i, &app_id)) {
         entry.reset(new base::DictionaryValue());
       } else if (apps_list->GetDictionary(i, &app_entry)) {
         if (!app_entry->GetString(kIdAttr, &app_id)) {
           LOG(ERROR) << "Wrong format of default application list";
           prefs->Clear();
           break;
         }
         entry = app_entry->CreateDeepCopy();
         entry->Remove(kIdAttr, nullptr);
@@ skipping 84 matching lines @@
 }
 
 // static
 void ServicesCustomizationDocument::ShutdownForTesting() {
   delete g_test_services_customization_document;
   g_test_services_customization_document = NULL;
 }
 
 void ServicesCustomizationDocument::StartOEMWallpaperDownload(
     const GURL& wallpaper_url,
-    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
+    std::unique_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
   DCHECK(wallpaper_url.is_valid());
 
   const base::FilePath dir = GetCustomizedWallpaperCacheDir();
   const base::FilePath file = GetCustomizedWallpaperDownloadedFileName();
   if (dir.empty() || file.empty()) {
     NOTREACHED();
     applying->Finished(false);
     return;
   }
 
   wallpaper_downloader_.reset(new CustomizationWallpaperDownloader(
       g_browser_process->system_request_context(), wallpaper_url, dir, file,
       base::Bind(&ServicesCustomizationDocument::OnOEMWallpaperDownloaded,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(applying)))));
 
   wallpaper_downloader_->Start();
 }
 
 void ServicesCustomizationDocument::CheckAndApplyWallpaper() {
   if (wallpaper_downloader_.get()) {
     VLOG(1) << "CheckAndApplyWallpaper(): download has already started.";
     return;
   }
-  scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying(
+  std::unique_ptr<ServicesCustomizationDocument::ApplyingTask> applying(
       new ServicesCustomizationDocument::ApplyingTask(this));
 
   GURL wallpaper_url;
   if (!GetDefaultWallpaperUrl(&wallpaper_url)) {
     PrefService* pref_service = g_browser_process->local_state();
     std::string current_url =
         pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
     if (!current_url.empty()) {
       VLOG(1) << "ServicesCustomizationDocument::CheckAndApplyWallpaper() : "
               << "No wallpaper URL attribute in customization document, "
               << "but current value is non-empty: '" << current_url
               << "'. Ignored.";
     }
     applying->Finished(true);
     return;
   }
 
   // Should fail if this ever happens in tests.
   DCHECK(wallpaper_url.is_valid());
   if (!wallpaper_url.is_valid()) {
     if (!wallpaper_url.is_empty()) {
       LOG(WARNING) << "Invalid Customized Wallpaper URL '"
                    << wallpaper_url.spec() << "'.";
     }
     applying->Finished(false);
     return;
   }
 
-  scoped_ptr<bool> exists(new bool(false));
+  std::unique_ptr<bool> exists(new bool(false));
 
   base::Closure check_file_exists =
       base::Bind(&CheckWallpaperCacheExists,
                  GetCustomizedWallpaperDownloadedFileName(),
                  base::Unretained(exists.get()));
   base::Closure on_checked_closure = base::Bind(
       &ServicesCustomizationDocument::OnCheckedWallpaperCacheExists,
       weak_ptr_factory_.GetWeakPtr(), base::Passed(std::move(exists)),
       base::Passed(std::move(applying)));
   if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
           FROM_HERE, check_file_exists, on_checked_closure)) {
     LOG(WARNING) << "Failed to start check Wallpaper cache exists.";
   }
 }
 
 void ServicesCustomizationDocument::OnCheckedWallpaperCacheExists(
-    scoped_ptr<bool> exists,
-    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
+    std::unique_ptr<bool> exists,
+    std::unique_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(exists);
   DCHECK(applying);
 
   ApplyWallpaper(*exists, std::move(applying));
 }
 
 void ServicesCustomizationDocument::ApplyWallpaper(
     bool default_wallpaper_file_exists,
-    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
+    std::unique_ptr<ServicesCustomizationDocument::ApplyingTask> applying) {
   GURL wallpaper_url;
   const bool wallpaper_url_present = GetDefaultWallpaperUrl(&wallpaper_url);
 
   PrefService* pref_service = g_browser_process->local_state();
 
   std::string current_url =
       pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
   if (current_url != wallpaper_url.spec()) {
     if (wallpaper_url_present) {
       VLOG(1) << "ServicesCustomizationDocument::ApplyWallpaper() : "
@@ skipping 24 matching lines @@
         << "ServicesCustomizationDocument::ApplyWallpaper() : reuse existing";
     OnOEMWallpaperDownloaded(std::move(applying), true, GURL(current_url));
   } else {
     VLOG(1)
         << "ServicesCustomizationDocument::ApplyWallpaper() : start download";
     StartOEMWallpaperDownload(wallpaper_url, std::move(applying));
   }
 }
 
 void ServicesCustomizationDocument::OnOEMWallpaperDownloaded(
-    scoped_ptr<ServicesCustomizationDocument::ApplyingTask> applying,
+    std::unique_ptr<ServicesCustomizationDocument::ApplyingTask> applying,
     bool success,
     const GURL& wallpaper_url) {
   if (success) {
     DCHECK(wallpaper_url.is_valid());
 
     VLOG(1) << "Setting default wallpaper to '"
             << GetCustomizedWallpaperDownloadedFileName().value() << "' ('"
             << wallpaper_url.spec() << "')";
     WallpaperManager::Get()->SetCustomizedDefaultWallpaper(
         wallpaper_url,
@@ skipping 15 matching lines @@
   apply_tasks_success_ += success;
 
   if (apply_tasks_started_ != apply_tasks_finished_)
     return;
 
   if (apply_tasks_success_ == apply_tasks_finished_)
     SetApplied(true);
 }
 
 }  // namespace chromeos