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

chrome/browser/chromeos/extensions/wallpaper_api.cc

 // Copyright 2013 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/extensions/wallpaper_api.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 68 matching lines @@
   }
 
   void CancelPreviousFetch() {
     if (url_fetcher_.get()) {
       callback_.Run(false, wallpaper_api_util::kCancelWallpaperMessage);
       callback_.Reset();
       url_fetcher_.reset();
     }
   }
 
-  scoped_ptr<net::URLFetcher> url_fetcher_;
+  std::unique_ptr<net::URLFetcher> url_fetcher_;
   FetchCallback callback_;
 };
 
 base::LazyInstance<WallpaperFetcher> g_wallpaper_fetcher =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 WallpaperSetWallpaperFunction::WallpaperSetWallpaperFunction() {
 }
@@ skipping 70 matching lines @@
     profile->GetPrefs()->SetString(prefs::kCurrentWallpaperAppName,
                                    extension()->name());
   }
 
   if (!params_->details.thumbnail)
     SendResponse(true);
 
   // We need to generate thumbnail image anyway to make the current third party
   // wallpaper syncable through different devices.
   image.EnsureRepsForSupportedScales();
-  scoped_ptr<gfx::ImageSkia> deep_copy(image.DeepCopy());
+  std::unique_ptr<gfx::ImageSkia> deep_copy(image.DeepCopy());
   // Generates thumbnail before call api function callback. We can then
   // request thumbnail in the javascript callback.
   task_runner->PostTask(
       FROM_HERE,
       base::Bind(&WallpaperSetWallpaperFunction::GenerateThumbnail, this,
                  thumbnail_path, base::Passed(std::move(deep_copy))));
 }
 
 void WallpaperSetWallpaperFunction::GenerateThumbnail(
-    const base::FilePath& thumbnail_path, scoped_ptr<gfx::ImageSkia> image) {
+    const base::FilePath& thumbnail_path,
+    std::unique_ptr<gfx::ImageSkia> image) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       sequence_token_));
   if (!base::PathExists(thumbnail_path.DirName()))
     base::CreateDirectory(thumbnail_path.DirName());
 
   scoped_refptr<base::RefCountedBytes> original_data;
   scoped_refptr<base::RefCountedBytes> thumbnail_data;
   chromeos::WallpaperManager::Get()->ResizeImage(
       *image, wallpaper::WALLPAPER_LAYOUT_STRETCH, image->width(),
       image->height(), &original_data, NULL);
@@ skipping 22 matching lines @@
     SetResult(thumbnail_result);
     SendResponse(true);
   }
 
   // Inform the native Wallpaper Picker Application that the current wallpaper
   // has been modified by a third party application.
   if (extension()->id() != extension_misc::kWallpaperManagerId) {
     Profile* profile = Profile::FromBrowserContext(browser_context());
     extensions::EventRouter* event_router =
         extensions::EventRouter::Get(profile);
-    scoped_ptr<base::ListValue> event_args(new base::ListValue());
+    std::unique_ptr<base::ListValue> event_args(new base::ListValue());
     event_args->Append(original_result);
     event_args->Append(thumbnail_result);
     event_args->Append(new base::StringValue(
         extensions::api::wallpaper::ToString(params_->details.layout)));
     event_args->Append(new base::StringValue(extension()->name()));
-    scoped_ptr<extensions::Event> event(new extensions::Event(
+    std::unique_ptr<extensions::Event> event(new extensions::Event(
         extensions::events::WALLPAPER_PRIVATE_ON_WALLPAPER_CHANGED_BY_3RD_PARTY,
         extensions::api::wallpaper_private::OnWallpaperChangedBy3rdParty::
             kEventName,
         std::move(event_args)));
     event_router->DispatchEventToExtension(extension_misc::kWallpaperManagerId,
                                            std::move(event));
   }
 }
 
 void WallpaperSetWallpaperFunction::OnWallpaperFetched(
     bool success,
     const std::string& response) {
   if (success) {
     params_->details.data.reset(
         new std::vector<char>(response.begin(), response.end()));
     StartDecode(*params_->details.data);
   } else {
     SetError(response);
     SendResponse(false);
   }
 }