[ObjC ARC] Converts ios/chrome/browser/webp_transcode:unit_tests to ARC.Automatically generated A…

ios/chrome/browser/webp_transcode/webp_decoder_unittest.mm

 // Copyright 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 "ios/chrome/browser/webp_transcode/webp_decoder.h"
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/base_paths.h"
 #include "base/files/file_path.h"
 #include "base/ios/ios_util.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/sys_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace webp_transcode {
 namespace {
 
 class WebpDecoderDelegate : public WebpDecoder::Delegate {
  public:
   WebpDecoderDelegate() : image_([[NSMutableData alloc] init]) {}
 
   NSData* GetImage() const { return image_; }
 
   // WebpDecoder::Delegate methods.
@@ skipping 126 matching lines @@
 }  // namespace
 
 TEST_F(WebpDecoderTest, DecodeToJpeg) {
 // TODO(droger): This test fails on iOS 9 x64 devices. http://crbug.com/523235
 #if defined(OS_IOS) && defined(ARCH_CPU_ARM64) && !TARGET_IPHONE_SIMULATOR
   if (base::ios::IsRunningOnIOS9OrLater())
     return;
 #endif
   // Load a WebP image from disk.
   base::scoped_nsobject<NSData> webp_image(
-      [LoadImage(base::FilePath("test.webp")) retain]);
+      LoadImage(base::FilePath("test.webp")));
   ASSERT_TRUE(webp_image != nil);
   // Load reference image.
   base::scoped_nsobject<NSData> jpg_image(
-      [LoadImage(base::FilePath("test.jpg")) retain]);
+      LoadImage(base::FilePath("test.jpg")));
   ASSERT_TRUE(jpg_image != nil);
   // Convert to JPEG.
   EXPECT_CALL(*delegate_, OnFinishedDecoding(true)).Times(1);
   EXPECT_CALL(*delegate_, SetImageFeatures(testing::_, WebpDecoder::JPEG))
       .Times(1);
   decoder_->OnDataReceived(webp_image);
   // Compare to reference image.
   EXPECT_TRUE(CheckCompressedImagesEqual(jpg_image, delegate_->GetImage(),
                                          WebpDecoder::JPEG));
 }
 
 TEST_F(WebpDecoderTest, DecodeToPng) {
 // TODO(droger): This test fails on iOS 9 x64 devices. http://crbug.com/523235
 #if defined(OS_IOS) && defined(ARCH_CPU_ARM64) && !TARGET_IPHONE_SIMULATOR
   if (base::ios::IsRunningOnIOS9OrLater())
     return;
 #endif
   // Load a WebP image from disk.
   base::scoped_nsobject<NSData> webp_image(
-      [LoadImage(base::FilePath("test_alpha.webp")) retain]);
+      LoadImage(base::FilePath("test_alpha.webp")));
   ASSERT_TRUE(webp_image != nil);
   // Load reference image.
   base::scoped_nsobject<NSData> png_image(
-      [LoadImage(base::FilePath("test_alpha.png")) retain]);
+      LoadImage(base::FilePath("test_alpha.png")));
   ASSERT_TRUE(png_image != nil);
   // Convert to PNG.
   EXPECT_CALL(*delegate_, OnFinishedDecoding(true)).Times(1);
   EXPECT_CALL(*delegate_, SetImageFeatures(testing::_, WebpDecoder::PNG))
       .Times(1);
   decoder_->OnDataReceived(webp_image);
   // Compare to reference image.
   EXPECT_TRUE(CheckCompressedImagesEqual(png_image, delegate_->GetImage(),
                                          WebpDecoder::PNG));
 }
 
 TEST_F(WebpDecoderTest, DecodeToTiff) {
 // TODO(droger): This test fails on iOS 9 x64 devices. http://crbug.com/523235
 #if defined(OS_IOS) && defined(ARCH_CPU_ARM64) && !TARGET_IPHONE_SIMULATOR
   if (base::ios::IsRunningOnIOS9OrLater())
     return;
 #endif
   // Load a WebP image from disk.
   base::scoped_nsobject<NSData> webp_image(
-      [LoadImage(base::FilePath("test_small.webp")) retain]);
+      LoadImage(base::FilePath("test_small.webp")));
   ASSERT_TRUE(webp_image != nil);
   // Load reference image.
   base::scoped_nsobject<NSData> tiff_image(
-      [LoadImage(base::FilePath("test_small.tiff")) retain]);
+      LoadImage(base::FilePath("test_small.tiff")));
   ASSERT_TRUE(tiff_image != nil);
   // Convert to TIFF.
   EXPECT_CALL(*delegate_, OnFinishedDecoding(true)).Times(1);
   EXPECT_CALL(*delegate_,
               SetImageFeatures([tiff_image length], WebpDecoder::TIFF))
       .Times(1);
   decoder_->OnDataReceived(webp_image);
   // Compare to reference image.
   EXPECT_TRUE(CheckTiffImagesEqual(tiff_image, delegate_->GetImage()));
 }
 
 TEST_F(WebpDecoderTest, StreamedDecode) {
 // TODO(droger): This test fails on iOS 9 x64 devices. http://crbug.com/523235
 #if defined(OS_IOS) && defined(ARCH_CPU_ARM64) && !TARGET_IPHONE_SIMULATOR
   if (base::ios::IsRunningOnIOS9OrLater())
     return;
 #endif
   // Load a WebP image from disk.
   base::scoped_nsobject<NSData> webp_image(
-      [LoadImage(base::FilePath("test.webp")) retain]);
+      LoadImage(base::FilePath("test.webp")));
   ASSERT_TRUE(webp_image != nil);
   // Load reference image.
   base::scoped_nsobject<NSData> jpg_image(
-      [LoadImage(base::FilePath("test.jpg")) retain]);
+      LoadImage(base::FilePath("test.jpg")));
   ASSERT_TRUE(jpg_image != nil);
   // Convert to JPEG in chunks.
   EXPECT_CALL(*delegate_, OnFinishedDecoding(true)).Times(1);
   EXPECT_CALL(*delegate_, SetImageFeatures(testing::_, WebpDecoder::JPEG))
       .Times(1);
   const size_t kChunkSize = 10;
   unsigned int num_chunks = 0;
   while ([webp_image length] > kChunkSize) {
     base::scoped_nsobject<NSData> chunk(
-        [[webp_image subdataWithRange:NSMakeRange(0, kChunkSize)] retain]);
+        [webp_image subdataWithRange:NSMakeRange(0, kChunkSize)]);
     decoder_->OnDataReceived(chunk);
-    webp_image.reset([[webp_image
-        subdataWithRange:NSMakeRange(kChunkSize, [webp_image length] -
-                                                     kChunkSize)] retain]);
+    webp_image.reset([webp_image
+        subdataWithRange:NSMakeRange(kChunkSize,
+                                     [webp_image length] - kChunkSize)]);
     ++num_chunks;
   }
   if ([webp_image length] > 0u) {
     decoder_->OnDataReceived(webp_image);
     ++num_chunks;
   }
   ASSERT_GT(num_chunks, 3u) << "Not enough chunks";
   // Compare to reference image.
   EXPECT_TRUE(CheckCompressedImagesEqual(jpg_image, delegate_->GetImage(),
                                          WebpDecoder::JPEG));
 }
 
 TEST_F(WebpDecoderTest, InvalidFormat) {
   EXPECT_CALL(*delegate_, OnFinishedDecoding(false)).Times(1);
   const char dummy_image[] = "(>'-')> <('-'<) ^('-')^ <('-'<) (>'-')>";
   base::scoped_nsobject<NSData> data(
       [[NSData alloc] initWithBytes:dummy_image length:arraysize(dummy_image)]);
   decoder_->OnDataReceived(data);
   EXPECT_EQ(0u, [delegate_->GetImage() length]);
 }
 
 TEST_F(WebpDecoderTest, DecodeAborted) {
   EXPECT_CALL(*delegate_, OnFinishedDecoding(false)).Times(1);
   decoder_->Stop();
   EXPECT_EQ(0u, [delegate_->GetImage() length]);
 }
 
 }  // namespace webp_transcode