Add a static method to WebPDecoder to decode WebP

components/image_fetcher/ios/ios_image_data_fetcher_wrapper.mm

 // Copyright 2017 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 "components/image_fetcher/ios/ios_image_data_fetcher_wrapper.h"
 
 #import "base/mac/bind_objc_block.h"
-#import "base/mac/scoped_nsobject.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #import "ios/web/public/image_fetcher/webp_decoder.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "url/url_constants.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
-#pragma mark - WebpDecoderDelegate
-
-namespace {
-
-// TODO(crbug.com/687921): Refactor this.
-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 = default;
-  NSMutableData* decoded_image_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebpDecoderDelegate);
-};
-
-// Content-type header for WebP images.
-const char kWEBPFirstMagicPattern[] = "RIFF";
-const char kWEBPSecondMagicPattern[] = "WEBP";
-
-// Returns a NSData object containing the decoded image.
-// Returns nil in case of failure.
-NSData* 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();
-}
-
-}  // namespace
-
 #pragma mark - IOSImageDataFetcherWrapper
 
 namespace image_fetcher {
 
 IOSImageDataFetcherWrapper::IOSImageDataFetcherWrapper(
     net::URLRequestContextGetter* url_request_context_getter,
     const scoped_refptr<base::TaskRunner>& task_runner)
     : task_runner_(task_runner),
       image_data_fetcher_(url_request_context_getter) {
   DCHECK(task_runner_.get());
@@ skipping 29 matching lines @@
 IOSImageDataFetcherWrapper::CallbackForImageDataFetcher(
     IOSImageDataFetcherCallback callback) {
   scoped_refptr<base::TaskRunner> task_runner = task_runner_;
 
   return base::BindBlockArc(^(const std::string& image_data,
                               const RequestMetadata& metadata) {
     // Create a NSData from the returned data and notify the callback.
     NSData* data =
         [NSData dataWithBytes:image_data.data() length:image_data.size()];
 
-    if (data.length < 12 ||
-        image_data.compare(0, 4, kWEBPFirstMagicPattern) != 0 ||
-        image_data.compare(8, 4, kWEBPSecondMagicPattern) != 0) {
+    if (!webp_transcode::WebpDecoder::IsWebpImage(image_data)) {
       callback(data, metadata);
       return;
     }
 
+    // The image is a webp image.
     RequestMetadata webp_metadata = metadata;
 
-    // The image is a webp image.
-    base::PostTaskAndReplyWithResult(task_runner.get(), FROM_HERE,
-                                     base::Bind(&DecodeWebpImage, data),
-                                     base::BindBlockArc(^(NSData* data) {
-                                       callback(data, webp_metadata);
-                                     }));
+    base::PostTaskAndReplyWithResult(
+        task_runner.get(), FROM_HERE, base::BindBlockArc(^NSData* {

[sdefresne, 2017/02/16 17:10:32]

I think this should be

  task_runner.get(), FROM_HERE, base::BindBlockArc(^NSData*() {

[gambard, 2017/02/17 08:30:59]

Why?

[sdefresne, 2017/02/17 10:22:55]

What you wrote is technically correct, however, it quite uncommon to omit the
argument list but not the return type in a block declaration. It's frequent to
omit the return type to have it inferred, or both if the argument list is empty
and you want the return type inferred. Your usage is quite uncommon though.

I'd prefer either you completely omit the return type (^{...}) and argument list
or list them both (^NSData*(){...}).

+          return webp_transcode::WebpDecoder::DecodeWebpImage(data);
+        }),
+        base::BindBlockArc(^(NSData* decodedData) {
+          callback(decodedData, webp_metadata);
+        }));
   });
 }
 
 }  // namespace image_fetcher