Create the IOSImageDataFetcher

components/image_fetcher/ios/ios_image_data_fetcher.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.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 "components/image_fetcher/image_data_fetcher.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 {
+
+class WebpDecoderDelegate : public webp_transcode::WebpDecoder::Delegate {
+ public:
+  NSData* data() const { return decoded_image_; }
+
+  // WebpDecoder::Delegate methods
+  void OnFinishedDecoding(bool success) override {
+    if (!success)
+      decoded_image_.reset();
+  }
+  void SetImageFeatures(
+      size_t total_size,
+      webp_transcode::WebpDecoder::DecodedImageFormat format) override {
+    decoded_image_.reset([[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_;
+};
+
+// Content-type header for WebP images.
+static const char kWEBPMimeType[] = "image/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 base::scoped_nsobject<NSData>(delegate->data());
+}
+
+}  // namespace
+
+#pragma mark - IOSImageDataFetcher
+
+namespace image_fetcher {
+
+IOSImageDataFetcher::IOSImageDataFetcher(
+    net::URLRequestContextGetter* url_request_context_getter,
+    const scoped_refptr<base::TaskRunner>& task_runner)
+    : task_runner_(task_runner) {
+  DCHECK(task_runner_.get());
+  image_data_fetcher_ =
+      base::MakeUnique<ImageDataFetcher>(url_request_context_getter);
+}
+
+IOSImageDataFetcher::~IOSImageDataFetcher() {}
+
+void IOSImageDataFetcher::FetchImageDataWebpDecoded(
+    const GURL& image_url,
+    IOSImageDataFetcherCallback callback) {
+  DCHECK(callback);
+  if (!callback)
+    return;
+
+  scoped_refptr<base::TaskRunner> task_runner = task_runner_;
+  ImageDataFetcher::ImageDataFetcherCallback local_callback =
+      base::BindBlockArc(^(const std::string& image_data,
+                           const net::URLFetcher* source) {
+        // Make sure the request was successful. For "data" requests, the
+        // response code has no meaning, because there is no actual server (data
+        // is encoded directly in the URL). In that case, set the response code
+        // to 200 (OK).
+        const GURL& original_url = source->GetOriginalURL();
+        const int http_response_code = original_url.SchemeIs(url::kDataScheme)
+                                           ? net::HTTP_OK
+                                           : source->GetResponseCode();
+        if (http_response_code != net::HTTP_OK) {
+          callback(http_response_code, nil);
+          return;
+        }
+
+        // Create a NSData from the returned data and notify the callback.
+        NSData* data =
+            [NSData dataWithBytes:image_data.data() length:image_data.size()];
+
+        if (source->GetResponseHeaders()) {
+          std::string mime_type;
+          source->GetResponseHeaders()->GetMimeType(&mime_type);
+          if (mime_type == kWEBPMimeType) {
+            base::PostTaskAndReplyWithResult(
+                task_runner.get(), FROM_HERE,
+                base::Bind(&DecodeWebpImage, data),
+                base::BindBlockArc(^(NSData* decodedData) {
+                  callback(http_response_code, decodedData);
+                }));
+            return;
+          }
+        }
+        callback(http_response_code, data);
+      });
+  image_data_fetcher_->FetchImageData(image_url, local_callback);
+}
+
+void IOSImageDataFetcher::SetDataUseServiceName(
+    DataUseServiceName data_use_service_name) {
+  image_data_fetcher_->SetDataUseServiceName(data_use_service_name);
+}
+
+}  // namespace image_fetcher