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

chrome/browser/chromeos/customization/customization_wallpaper_downloader_browsertest.cc

 // Copyright 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 <stddef.h>
 
 #include <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
@@ skipping 84 matching lines @@
       const GURL& url,
       const size_t require_retries,
       const std::vector<unsigned char>& jpeg_data_raw)
       : url_(url),
         require_retries_(require_retries),
         factory_(NULL) {
     jpeg_data_.resize(jpeg_data_raw.size());
     std::copy(jpeg_data_raw.begin(), jpeg_data_raw.end(), jpeg_data_.begin());
   }
 
-  scoped_ptr<net::FakeURLFetcher> CreateURLFetcher(
+  std::unique_ptr<net::FakeURLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* delegate,
       const std::string& response_data,
       net::HttpStatusCode response_code,
       net::URLRequestStatus::Status status) {
     chromeos::ServicesCustomizationDocument* customization =
         chromeos::ServicesCustomizationDocument::GetInstance();
     customization->wallpaper_downloader_for_testing()
         ->set_retry_delay_for_testing(
             base::TimeDelta::FromMilliseconds(kDownloadRetryIntervalMS));
@@ skipping 11 matching lines @@
           << "Retry too fast. Actual interval " << current_delay.InSecondsF()
           << " seconds, but expected at least " << base_interval
           << " * (retry=" << retry
           << " * retry)= " << base_interval * retry * retry << " seconds.";
     }
     if (attempts_.size() > require_retries_) {
       response_code = net::HTTP_OK;
       status = net::URLRequestStatus::SUCCESS;
       factory_->SetFakeResponse(url, response_data, response_code, status);
     }
-    scoped_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
+    std::unique_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
         url, delegate, response_data, response_code, status));
     scoped_refptr<net::HttpResponseHeaders> download_headers =
         new net::HttpResponseHeaders(std::string());
     download_headers->AddHeader("Content-Type: image/jpeg");
     fetcher->set_response_headers(download_headers);
     return fetcher;
   }
 
   void Initialize(net::FakeURLFetcherFactory* factory) {
     factory_ = factory;
@@ skipping 52 matching lines @@
         url, require_retries, oem_wallpaper_));
     fallback_fetcher_factory_.reset(new net::TestURLFetcherFactory);
     net::URLFetcherImpl::set_factory(NULL);
     fetcher_factory_.reset(new net::FakeURLFetcherFactory(
         fallback_fetcher_factory_.get(),
         base::Bind(&TestWallpaperImageURLFetcherCallback::CreateURLFetcher,
                    base::Unretained(url_callback_.get()))));
     url_callback_->Initialize(fetcher_factory_.get());
   }
 
-  scoped_ptr<TestWallpaperImageURLFetcherCallback> url_callback_;
+  std::unique_ptr<TestWallpaperImageURLFetcherCallback> url_callback_;
 
   // Use a test factory as a fallback so we don't have to deal with other
   // requests.
-  scoped_ptr<net::TestURLFetcherFactory> fallback_fetcher_factory_;
-  scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
+  std::unique_ptr<net::TestURLFetcherFactory> fallback_fetcher_factory_;
+  std::unique_ptr<net::FakeURLFetcherFactory> fetcher_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperImageFetcherFactory);
 };
 
 class CustomizationWallpaperDownloaderBrowserTest
     : public InProcessBrowserTest {
  public:
   CustomizationWallpaperDownloaderBrowserTest()
       : controller_(NULL),
         local_state_(NULL) {
@@ skipping 16 matching lines @@
  protected:
   void CreateCmdlineWallpapers() {
     cmdline_wallpaper_dir_.reset(new base::ScopedTempDir);
     ASSERT_TRUE(cmdline_wallpaper_dir_->CreateUniqueTempDir());
     wallpaper_manager_test_utils::CreateCmdlineWallpapers(
         *cmdline_wallpaper_dir_, &wallpaper_manager_command_line_);
   }
 
   ash::DesktopBackgroundController* controller_;
   PrefService* local_state_;
-  scoped_ptr<base::CommandLine> wallpaper_manager_command_line_;
+  std::unique_ptr<base::CommandLine> wallpaper_manager_command_line_;
 
   // Directory created by CreateCmdlineWallpapersAndSetFlags() to store default
   // wallpaper images.
-  scoped_ptr<base::ScopedTempDir> cmdline_wallpaper_dir_;
+  std::unique_ptr<base::ScopedTempDir> cmdline_wallpaper_dir_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CustomizationWallpaperDownloaderBrowserTest);
 };
 
 IN_PROC_BROWSER_TEST_F(CustomizationWallpaperDownloaderBrowserTest,
                        OEMWallpaperIsPresent) {
   CreateCmdlineWallpapers();
   WallpaperManager::Get()->SetDefaultWallpaperNow(EmptyAccountId());
   wallpaper_manager_test_utils::WaitAsyncWallpaperLoadFinished();
@@ skipping 45 matching lines @@
 
   observer.WaitForWallpaperAnimationFinished();
   EXPECT_TRUE(wallpaper_manager_test_utils::ImageIsNearColor(
       controller_->GetWallpaper(),
       wallpaper_manager_test_utils::kCustomWallpaperColor));
 
   EXPECT_EQ(2U, url_factory.num_attempts());
 }
 
 }  // namespace chromeos