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

chrome/browser/chromeos/customization/customization_document.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CUSTOMIZATION_CUSTOMIZATION_DOCUMENT_H_
 #define CHROME_BROWSER_CHROMEOS_CUSTOMIZATION_CUSTOMIZATION_DOCUMENT_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
 class PrefRegistrySimple;
 class Profile;
 
 namespace base {
@@ skipping 35 matching lines @@
  protected:
   explicit CustomizationDocument(const std::string& accepted_version);
 
   virtual bool LoadManifestFromFile(const base::FilePath& manifest_path);
   virtual bool LoadManifestFromString(const std::string& manifest);
 
   std::string GetLocaleSpecificString(const std::string& locale,
                                       const std::string& dictionary_name,
                                       const std::string& entry_name) const;
 
-  scoped_ptr<base::DictionaryValue> root_;
+  std::unique_ptr<base::DictionaryValue> root_;
 
   // Value of the "version" attribute that is supported.
   // Otherwise config is not loaded.
   std::string accepted_version_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CustomizationDocument);
 };
 
 // OEM startup customization document class.
@@ skipping 84 matching lines @@
 
   // Apply customization and save in machine options that customization was
   // applied successfully. Return true if customization was applied.
   bool ApplyOOBECustomization();
 
   // Returns true if default wallpaper URL attribute found in manifest.
   // |out_url| is set to attribute value.
   bool GetDefaultWallpaperUrl(GURL* out_url) const;
 
   // Returns list of default apps.
-  scoped_ptr<base::DictionaryValue> GetDefaultApps() const;
+  std::unique_ptr<base::DictionaryValue> GetDefaultApps() const;
 
   // Creates an extensions::ExternalLoader that will provide OEM default apps.
   // Cache of OEM default apps stored in profile preferences.
   extensions::ExternalLoader* CreateExternalLoader(Profile* profile);
 
   // Returns the name of the folder for OEM apps for given |locale|.
   std::string GetOemAppsFolderName(const std::string& locale) const;
 
   // Initialize instance of ServicesCustomizationDocument for tests that will
   // override singleton until ShutdownForTesting is called.
@@ skipping 53 matching lines @@
       base::WeakPtr<ServicesCustomizationDocument> self,
       const base::FilePath& file);
 
   // Called on UI thread with results of ReadFileInBackground.
   void OnManifesteRead(const std::string& manifest);
 
   // Method called when manifest was successfully loaded.
   void OnManifestLoaded();
 
   // Returns list of default apps in ExternalProvider format.
-  static scoped_ptr<base::DictionaryValue> GetDefaultAppsInProviderFormat(
+  static std::unique_ptr<base::DictionaryValue> GetDefaultAppsInProviderFormat(
       const base::DictionaryValue& root);
 
   // Update cached manifest for |profile|.
   void UpdateCachedManifest(Profile* profile);
 
   // Customization document not found for give ID.
   void OnCustomizationNotFound();
 
   // Set OEM apps folder name for AppListSyncableService for |profile|.
   void SetOemFolderName(Profile* profile, const base::DictionaryValue& root);
 
   // Returns the name of the folder for OEM apps for given |locale|.
   std::string GetOemAppsFolderNameImpl(
       const std::string& locale,
       const base::DictionaryValue& root) const;
 
   // Start download of wallpaper image if needed.
   void StartOEMWallpaperDownload(const GURL& wallpaper_url,
-                                 scoped_ptr<ApplyingTask> applying);
+                                 std::unique_ptr<ApplyingTask> applying);
 
   // Check that current customized wallpaper cache exists. Once wallpaper is
   // downloaded, it's never updated (even if manifest is re-fetched).
   // Start wallpaper download if needed.
   void CheckAndApplyWallpaper();
 
   // Intermediate function to pass the result of PathExists to ApplyWallpaper.
-  void OnCheckedWallpaperCacheExists(scoped_ptr<bool> exists,
-                                     scoped_ptr<ApplyingTask> applying);
+  void OnCheckedWallpaperCacheExists(std::unique_ptr<bool> exists,
+                                     std::unique_ptr<ApplyingTask> applying);
 
   // Called after downloaded wallpaper has been checked.
   void ApplyWallpaper(bool default_wallpaper_file_exists,
-                      scoped_ptr<ApplyingTask> applying);
+                      std::unique_ptr<ApplyingTask> applying);
 
   // Set Shell default wallpaper to customized.
   // It's wrapped as a callback and passed as a parameter to
   // CustomizationWallpaperDownloader.
-  void OnOEMWallpaperDownloaded(scoped_ptr<ApplyingTask> applying,
+  void OnOEMWallpaperDownloaded(std::unique_ptr<ApplyingTask> applying,
                                 bool success,
                                 const GURL& wallpaper_url);
 
   // Register one of Customization applying tasks.
   void ApplyingTaskStarted();
 
   // Mark task finished and check for "all customization applied".
   void ApplyingTaskFinished(bool success);
 
   // Services customization manifest URL.
   GURL url_;
 
   // URLFetcher instance.
-  scoped_ptr<net::URLFetcher> url_fetcher_;
+  std::unique_ptr<net::URLFetcher> url_fetcher_;
 
   // How many times we already tried to fetch customization manifest file.
   int num_retries_;
 
   // Manifest fetch is already in progress.
   bool fetch_started_;
 
   // Delay between checks for network online state.
   base::TimeDelta network_delay_;
 
   // Known external loaders.
   ExternalLoaders external_loaders_;
 
-  scoped_ptr<CustomizationWallpaperDownloader> wallpaper_downloader_;
+  std::unique_ptr<CustomizationWallpaperDownloader> wallpaper_downloader_;
 
   // This is barrier until customization is applied.
   // When number of finished tasks match number of started - customization is
   // applied.
   size_t apply_tasks_started_;
   size_t apply_tasks_finished_;
 
   // This is the number of successfully finished customization tasks.
   // If it matches number of tasks finished - customization is applied
   // successfully.
   size_t apply_tasks_success_;
 
   // Weak factory for callbacks.
   base::WeakPtrFactory<ServicesCustomizationDocument> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServicesCustomizationDocument);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CUSTOMIZATION_CUSTOMIZATION_DOCUMENT_H_