Convert //ios from scoped_ptr to std::unique_ptr.

ios/chrome/browser/favicon/large_icon_cache_unittest.cc

 // Copyright 2015 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 "ios/chrome/browser/favicon/large_icon_cache.h"
 
 #include "base/macros.h"
 #include "components/favicon_base/fallback_icon_style.h"
 #include "components/favicon_base/favicon_types.h"
 #include "skia/ext/skia_utils_ios.h"
@@ skipping 32 matching lines @@
   LargeIconCacheTest() {
     expected_fallback_icon_style_.reset(new favicon_base::FallbackIconStyle());
     expected_fallback_icon_style_->background_color = kTestColor;
     expected_bitmap_ = CreateTestBitmap(24, 24, kTestColor);
     large_icon_cache_.reset(new LargeIconCache);
   }
 
   ~LargeIconCacheTest() override {}
 
  protected:
-  scoped_ptr<LargeIconCache> large_icon_cache_;
+  std::unique_ptr<LargeIconCache> large_icon_cache_;
   favicon_base::FaviconRawBitmapResult expected_bitmap_;
-  scoped_ptr<favicon_base::FallbackIconStyle> expected_fallback_icon_style_;
+  std::unique_ptr<favicon_base::FallbackIconStyle>
+      expected_fallback_icon_style_;
 
   bool is_callback_invoked_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LargeIconCacheTest);
 };
 
 TEST_F(LargeIconCacheTest, EmptyCache) {
-  scoped_ptr<LargeIconCache> large_icon_cache(new LargeIconCache);
+  std::unique_ptr<LargeIconCache> large_icon_cache(new LargeIconCache);
   EXPECT_EQ(nullptr, large_icon_cache->GetCachedResult(GURL(kDummyUrl)));
 }
 
 TEST_F(LargeIconCacheTest, RetreiveItem) {
-  scoped_ptr<favicon_base::LargeIconResult> expected_result1;
-  scoped_ptr<favicon_base::LargeIconResult> expected_result2;
+  std::unique_ptr<favicon_base::LargeIconResult> expected_result1;
+  std::unique_ptr<favicon_base::LargeIconResult> expected_result2;
   expected_result1.reset(new favicon_base::LargeIconResult(expected_bitmap_));
   expected_result2.reset(new favicon_base::LargeIconResult(
       new favicon_base::FallbackIconStyle(*expected_fallback_icon_style_)));
 
   large_icon_cache_->SetCachedResult(GURL(kDummyUrl), *expected_result1);
   large_icon_cache_->SetCachedResult(GURL(kDummyUrl2), *expected_result2);
 
-  scoped_ptr<favicon_base::LargeIconResult> result1 =
+  std::unique_ptr<favicon_base::LargeIconResult> result1 =
       large_icon_cache_->GetCachedResult(GURL(kDummyUrl));
   EXPECT_EQ(true, result1->bitmap.is_valid());
   EXPECT_EQ(expected_result1->bitmap.pixel_size, result1->bitmap.pixel_size);
 
-  scoped_ptr<favicon_base::LargeIconResult> result2 =
+  std::unique_ptr<favicon_base::LargeIconResult> result2 =
       large_icon_cache_->GetCachedResult(GURL(kDummyUrl2));
   EXPECT_EQ(false, result2->bitmap.is_valid());
   EXPECT_EQ(expected_result2->fallback_icon_style->background_color,
             result2->fallback_icon_style->background_color);
 
   // Test overwriting kDummyUrl.
   large_icon_cache_->SetCachedResult(GURL(kDummyUrl), *expected_result2);
-  scoped_ptr<favicon_base::LargeIconResult> result3 =
+  std::unique_ptr<favicon_base::LargeIconResult> result3 =
       large_icon_cache_->GetCachedResult(GURL(kDummyUrl2));
   EXPECT_EQ(false, result3->bitmap.is_valid());
   EXPECT_EQ(expected_result2->fallback_icon_style->background_color,
             result3->fallback_icon_style->background_color);
 }
 
 }  // namespace