Add a static method to WebPDecoder to decode WebP

ios/web/public/image_fetcher/webp_decoder.mm

 // 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.
 
 #import "ios/web/public/image_fetcher/webp_decoder.h"
 
 #import <Foundation/Foundation.h>
 #include <stdint.h>
 #import <UIKit/UIKit.h>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.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);
+};
+
+// Content-type header for WebP images.
+const char kWEBPFirstMagicPattern[] = "RIFF";
+const char kWEBPSecondMagicPattern[] = "WEBP";
+
 const uint8_t kNumIfdEntries = 15;
 const unsigned int kExtraDataSize = 16;
 // 10b for signature/header + n * 12b entries + 4b for IFD terminator:
 const unsigned int kExtraDataOffset = 10 + 12 * kNumIfdEntries + 4;
 const unsigned int kHeaderSize = kExtraDataOffset + kExtraDataSize;
 const int kRecompressionThreshold = 64 * 64;  // Threshold in pixels.
 const CGFloat kJpegQuality = 0.85;
 
 // Adapted from libwebp example dwebp.c.
 void PutLE16(uint8_t* const dst, uint32_t value) {
@@ skipping 54 matching lines @@
     PutLE32(tiff_header + 178, 0);
 
   memcpy(dst, tiff_header, kHeaderSize);
 }
 
 }  // namespace
 
 namespace webp_transcode {
 
 // static
+NSData* WebpDecoder::DecodeWebpImage(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 delegate->data();
+}
+
+// static
+bool WebpDecoder::IsWebpImage(const std::string& image_data) {
+  if (image_data.length() < 12)
+    return false;
+  return image_data.compare(0, 4, kWEBPFirstMagicPattern) == 0 &&
+         image_data.compare(8, 4, kWEBPSecondMagicPattern) == 0;
+}
+
+// static
 size_t WebpDecoder::GetHeaderSize() {
   return kHeaderSize;
 }
 
 WebpDecoder::WebpDecoder(WebpDecoder::Delegate* delegate)
     : delegate_(delegate), state_(READING_FEATURES), has_alpha_(0) {
   DCHECK(delegate_.get());
   const bool rv = WebPInitDecoderConfig(&config_);
   DCHECK(rv);
 }
@@ skipping 142 matching lines @@
   }
   UMA_HISTOGRAM_ENUMERATION("WebP.DecodedImageFormat", format,
                             DECODED_FORMAT_COUNT);
   delegate_->SetImageFeatures([result_data length], format);
   delegate_->OnDataDecoded(result_data);
   output_buffer_.reset();
   return true;
 }
 
 }  // namespace webp_transcode