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_ = nil;
  }

  void SetImageFeatures(
      size_t total_size,
      webp_transcode::WebpDecoder::DecodedImageFormat format) override {
    decoded_image_ = [[NSMutableData alloc] initWithCapacity:total_size];
  }

  void OnDataDecoded(NSData* data) override {
    DCHECK(decoded_image_);
    [decoded_image_ appendData:data];
  }

 private:
  ~WebpDecoderDelegate() override {}
  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());
}

// 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:
//                                  1 1
// Byte Nr.     0 1 2 3 4 5 6 7 8 9 0 1
// Byte value [ R I F F ? ? ? ? W E B P  ]
//
// For more information see:
// https://developers.google.com/speed/webp/docs/riff_container#webp_file_header
bool IsWebpImage(const std::string& image_data) {
  if (image_data.length() < 12)
    return false;
  return image_data.compare(0, 4, "RIFF") == 0 &&
         image_data.compare(8, 4, "WEBP") == 0;
}

}  // namespace

namespace suggestions {

class IOSImageDecoderImpl : public image_fetcher::ImageDecoder {
 public:
  explicit IOSImageDecoderImpl(scoped_refptr<base::TaskRunner> task_runner);
  ~IOSImageDecoderImpl() override;

  void DecodeImage(
      const std::string& image_data,
      const image_fetcher::ImageDecodedCallback& callback) override;

 private:
  void CreateUIImageAndRunCallback(
      const image_fetcher::ImageDecodedCallback& callback,
      const base::scoped_nsobject<NSData>& image_data);

  // The task runner used to decode images if necessary.
  const scoped_refptr<base::TaskRunner> task_runner_;

  // The WeakPtrFactory is used to cancel callbacks if ImageFetcher is
  // destroyed during WebP decoding.
  base::WeakPtrFactory<IOSImageDecoderImpl> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(IOSImageDecoderImpl);
};

IOSImageDecoderImpl::IOSImageDecoderImpl(
    scoped_refptr<base::TaskRunner> task_runner)
    : 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]);

  // 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);
  }
}

void IOSImageDecoderImpl::CreateUIImageAndRunCallback(
    const image_fetcher::ImageDecodedCallback& callback,
    const base::scoped_nsobject<NSData>& image_data) {
  // Decode the image data using UIImage.
  if (image_data) {
    // "Most likely" always returns 1x images.
    UIImage* ui_image = [UIImage imageWithData:image_data scale:1];
    if (ui_image) {
      // This constructor does not retain the image, but expects to take the
      // ownership, therefore, |ui_image| is retained here, but not released
      // afterwards.
      gfx::Image gfx_image(ui_image, base::scoped_policy::RETAIN);
      callback.Run(gfx_image);
      return;
    }
  }
  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