[ObjC ARC] Converts ios/chrome/browser/suggestions:suggestions to ARC.

ios/chrome/browser/suggestions/ios_image_decoder_impl.mm

 // Copyright 2016 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/suggestions/ios_image_decoder_impl.h"
 
 #import <UIKit/UIKit.h>
 
 #include "base/callback.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #import "ios/web/public/image_fetcher/webp_decoder.h"
 #include "ios/web/public/web_thread.h"
 #include "ui/gfx/image/image.h"
 
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
 namespace {
 
 class WebpDecoderDelegate : public webp_transcode::WebpDecoder::Delegate {
  public:
   WebpDecoderDelegate() = default;
 
   NSData* data() const { return decoded_image_; }
 
   // WebpDecoder::Delegate methods
   void OnFinishedDecoding(bool success) override {
     if (!success)
-      decoded_image_.reset();
+      decoded_image_ = nil;
   }
 
   void SetImageFeatures(
       size_t total_size,
       webp_transcode::WebpDecoder::DecodedImageFormat format) override {
-    decoded_image_.reset([[NSMutableData alloc] initWithCapacity:total_size]);
+    decoded_image_ = [[NSMutableData alloc] initWithCapacity:total_size];
   }
 
   void OnDataDecoded(NSData* data) override {
     DCHECK(decoded_image_);
     [decoded_image_ appendData:data];
   }
 
  private:
   ~WebpDecoderDelegate() override {}
-  base::scoped_nsobject<NSMutableData> decoded_image_;
+  NSMutableData* decoded_image_;
 
   DISALLOW_COPY_AND_ASSIGN(WebpDecoderDelegate);
 };
 
 // Returns an NSData object containing the decoded image data of the given
 // webp_image. Returns nil in case of failure.
 base::scoped_nsobject<NSData> DecodeWebpImage(
     const base::scoped_nsobject<NSData>& webp_image) {
   scoped_refptr<WebpDecoderDelegate> delegate(new WebpDecoderDelegate);
   scoped_refptr<webp_transcode::WebpDecoder> decoder(
       new webp_transcode::WebpDecoder(delegate.get()));
   decoder->OnDataReceived(webp_image);
   DLOG_IF(ERROR, !delegate->data()) << "WebP image decoding failed.";
-  return base::scoped_nsobject<NSData>([delegate->data() retain]);
+  return base::scoped_nsobject<NSData>(delegate->data());
 }
 
 // Returns true if the given image_data is a WebP image.
 //
 // Every WebP file contains a 12 byte file header in the beginning of the file.
 // A WebP file header starts with the four ASCII characters "RIFF". The next
 // four bytes contain the image size and the last four header bytes contain the
 // four ASCII characters "WEBP".
 //
 // WebP file header:
@@ skipping 43 matching lines @@
     : task_runner_(std::move(task_runner)), weak_factory_(this) {
   DCHECK(task_runner_.get());
 }
 
 IOSImageDecoderImpl::~IOSImageDecoderImpl() {}
 
 void IOSImageDecoderImpl::DecodeImage(
     const std::string& image_data,
     const image_fetcher::ImageDecodedCallback& callback) {
   // Convert the |image_data| std::string to an NSData buffer.
-  base::scoped_nsobject<NSData> data(
-      [[NSData dataWithBytesNoCopy:const_cast<char*>(image_data.c_str())
-                            length:image_data.length()
-                      freeWhenDone:NO] retain]);
+  base::scoped_nsobject<NSData> data([NSData
+      dataWithBytesNoCopy:const_cast<char*>(image_data.c_str())
+                   length:image_data.length()
+             freeWhenDone:NO]);
 
   // The WebP image format is not supported by iOS natively. Therefore WebP
   // images need to be decoded explicitly,
   if (IsWebpImage(image_data)) {
     base::PostTaskAndReplyWithResult(
         task_runner_.get(), FROM_HERE, base::Bind(&DecodeWebpImage, data),
         base::Bind(&IOSImageDecoderImpl::CreateUIImageAndRunCallback,
                    weak_factory_.GetWeakPtr(), callback));
   } else {
     CreateUIImageAndRunCallback(callback, data);
@@ skipping 19 matching lines @@
   gfx::Image empty_image;
   callback.Run(empty_image);
 }
 
 std::unique_ptr<image_fetcher::ImageDecoder> CreateIOSImageDecoder(
     scoped_refptr<base::TaskRunner> task_runner) {
   return base::MakeUnique<IOSImageDecoderImpl>(std::move(task_runner));
 }
 
 }  // namespace suggestions