Simplify image decoder selection.

third_party/WebKit/Source/platform/image-decoders/ImageDecoder.cpp

 /*
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 45 matching lines @@
 }
 
 inline bool MatchesCURSignature(const char* contents) {
   return !memcmp(contents, "\x00\x00\x02\x00", 4);
 }
 
 inline bool MatchesBMPSignature(const char* contents) {
   return !memcmp(contents, "BM", 2);
 }
 
-// This needs to be updated if we ever add a Matches*Signature() which requires
-// more characters.
 static constexpr size_t kLongestSignatureLength = sizeof("RIFF????WEBPVP") - 1;
 
 std::unique_ptr<ImageDecoder> ImageDecoder::Create(
     RefPtr<SegmentReader> data,
     bool data_complete,
     AlphaOption alpha_option,
     const ColorBehavior& color_behavior) {
-  // We need at least kLongestSignatureLength bytes to run the signature
-  // matcher.
+  // At least kLongestSignatureLength bytes are needed to sniff the signature.
   if (data->size() < kLongestSignatureLength)
     return nullptr;
 
   const size_t max_decoded_bytes =
       Platform::Current() ? Platform::Current()->MaxDecodedImageBytes()
                           : kNoDecodedImageByteLimit;
 
   // Access the first kLongestSignatureLength chars to sniff the signature.
   // (note: FastSharedBufferReader only makes a copy if the bytes are segmented)
   char buffer[kLongestSignatureLength];
   const FastSharedBufferReader fast_reader(data);
-  const ImageDecoder::SniffResult sniff_result = DetermineImageType(
-      fast_reader.GetConsecutiveData(0, kLongestSignatureLength, buffer),
-      kLongestSignatureLength);
+  const char* contents =
+      fast_reader.GetConsecutiveData(0, kLongestSignatureLength, buffer);
 
   std::unique_ptr<ImageDecoder> decoder;
-  switch (sniff_result) {
-    case SniffResult::JPEG:
-      decoder.reset(new JPEGImageDecoder(alpha_option, color_behavior,
-                                         max_decoded_bytes));
-      break;
-    case SniffResult::PNG:
-      decoder.reset(
-          new PNGImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
-      break;
-    case SniffResult::GIF:
-      decoder.reset(
-          new GIFImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
-      break;
-    case SniffResult::WEBP:
-      decoder.reset(new WEBPImageDecoder(alpha_option, color_behavior,
-                                         max_decoded_bytes));
-      break;
-    case SniffResult::ICO:
-      decoder.reset(
-          new ICOImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
-      break;
-    case SniffResult::BMP:
-      decoder.reset(
-          new BMPImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
-      break;
-    case SniffResult::kInvalid:
-      break;
+  if (MatchesJPEGSignature(contents)) {
+    decoder.reset(
+        new JPEGImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
+  } else if (MatchesPNGSignature(contents)) {
+    decoder.reset(
+        new PNGImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
+  } else if (MatchesGIFSignature(contents)) {
+    decoder.reset(
+        new GIFImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
+  } else if (MatchesWebPSignature(contents)) {
+    decoder.reset(
+        new WEBPImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
+  } else if (MatchesICOSignature(contents) || MatchesCURSignature(contents)) {
+    decoder.reset(
+        new ICOImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
+  } else if (MatchesBMPSignature(contents)) {
+    decoder.reset(
+        new BMPImageDecoder(alpha_option, color_behavior, max_decoded_bytes));
   }
 
   if (decoder)
     decoder->SetData(std::move(data), data_complete);
 
   return decoder;
 }
 
 bool ImageDecoder::HasSufficientDataToSniffImageType(const SharedBuffer& data) {
   return data.size() >= kLongestSignatureLength;
 }
 
-ImageDecoder::SniffResult ImageDecoder::DetermineImageType(const char* contents,
-                                                           size_t length) {
-  DCHECK_GE(length, kLongestSignatureLength);
-
-  if (MatchesJPEGSignature(contents))
-    return SniffResult::JPEG;
-  if (MatchesPNGSignature(contents))
-    return SniffResult::PNG;
-  if (MatchesGIFSignature(contents))
-    return SniffResult::GIF;
-  if (MatchesWebPSignature(contents))
-    return SniffResult::WEBP;
-  if (MatchesICOSignature(contents) || MatchesCURSignature(contents))
-    return SniffResult::ICO;
-  if (MatchesBMPSignature(contents))
-    return SniffResult::BMP;
-  return SniffResult::kInvalid;
-}
-
 size_t ImageDecoder::FrameCount() {
   const size_t old_size = frame_buffer_cache_.size();
   const size_t new_size = DecodeFrameCount();
   if (old_size != new_size) {
     frame_buffer_cache_.resize(new_size);
     for (size_t i = old_size; i < new_size; ++i) {
       frame_buffer_cache_[i].SetPremultiplyAlpha(premultiply_alpha_);
       InitializeNewFrame(i);
     }
   }
@@ skipping 416 matching lines @@
     }
 
     // For color spaces without an identifiable gamut, just fall through to
     // sRGB.
   }
 
   return SkColorSpace::MakeSRGB();
 }
 
 }  // namespace blink