Optimize yuv decoding fail check and remove the usage of unwanted variable.

third_party/WebKit/Source/platform/graphics/ImageFrameGenerator.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 77 matching lines @@
 
     return dst->installPixels(info, pixels_, row_bytes_);
   }
 
  private:
   SkImageInfo info_;
   void* pixels_;
   size_t row_bytes_;
 };
 
-static bool UpdateYUVComponentSizes(ImageDecoder* decoder,
+static void UpdateYUVComponentSizes(ImageDecoder* decoder,
                                     SkISize component_sizes[3],
                                     size_t component_width_bytes[3]) {
   if (!decoder->CanDecodeToYUV())
     return false;
 
   for (int yuv_index = 0; yuv_index < 3; ++yuv_index) {
     IntSize size = decoder->DecodedYUVSize(yuv_index);
     component_sizes[yuv_index].set(size.Width(), size.Height());
     component_width_bytes[yuv_index] = decoder->DecodedYUVWidthBytes(yuv_index);
   }
-
-  return true;
 }
 
 ImageFrameGenerator::ImageFrameGenerator(const SkISize& full_size,
                                          bool is_multi_frame,
                                          const ColorBehavior& color_behavior)
     : full_size_(full_size),
       decoder_color_behavior_(color_behavior),
       is_multi_frame_(is_multi_frame),
       decode_failed_(false),
-      yuv_decoding_failed_(false),
       frame_count_(0) {}
 
 ImageFrameGenerator::~ImageFrameGenerator() {
   ImageDecodingStore::Instance().RemoveCacheIndexedByGenerator(this);
 }
 
 bool ImageFrameGenerator::DecodeAndScale(
     SegmentReader* data,
     bool all_data_received,
     size_t index,
@@ skipping 63 matching lines @@
   decoder->SetImagePlanes(std::move(image_planes));
 
   DCHECK(decoder->CanDecodeToYUV());
 
   if (decoder->DecodeToYUV()) {
     SetHasAlpha(0, false);  // YUV is always opaque
     return true;
   }
 
   DCHECK(decoder->Failed());
-  yuv_decoding_failed_ = true;
   return false;
 }
 
 SkBitmap ImageFrameGenerator::TryToResumeDecode(
     SegmentReader* data,
     bool all_data_received,
     size_t index,
     const SkISize& scaled_size,
     SkBitmap::Allocator* allocator,
     ImageDecoder::AlphaOption alpha_option) {
@@ skipping 160 matching lines @@
   if (index < has_alpha_.size())
     return has_alpha_[index];
   return true;
 }
 
 bool ImageFrameGenerator::GetYUVComponentSizes(SegmentReader* data,
                                                SkYUVSizeInfo* size_info) {
   TRACE_EVENT2("blink", "ImageFrameGenerator::getYUVComponentSizes", "width",
                full_size_.width(), "height", full_size_.height());
 
-  if (yuv_decoding_failed_)
-    return false;
-
   std::unique_ptr<ImageDecoder> decoder = ImageDecoder::Create(
       data, true, ImageDecoder::kAlphaPremultiplied, decoder_color_behavior_);
   if (!decoder)
     return false;
 
   // Setting a dummy ImagePlanes object signals to the decoder that we want to
   // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummy_image_planes =
       WTF::WrapUnique(new ImagePlanes);
   decoder->SetImagePlanes(std::move(dummy_image_planes));
 
-  return UpdateYUVComponentSizes(decoder.get(), size_info->fSizes,
-                                 size_info->fWidthBytes);
+  UpdateYUVComponentSizes(decoder.get(), size_info->fSizes,
+                          size_info->fWidthBytes);
+
+  return true;
 }
 
 }  // namespace blink