Remove redundant reading and writing of data about SharedBuffer.

third_party/WebKit/Source/platform/graphics/DeferredImageDecoder.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 110 matching lines @@
   ImageFrame* frame = actual_decoder_->FrameBufferAtIndex(index);
   if (!frame || frame->GetStatus() == ImageFrame::kFrameEmpty)
     return nullptr;
 
   return (frame->GetStatus() == ImageFrame::kFrameComplete)
              ? frame->FinalizePixelsAndGetImage()
              : SkImage::MakeFromBitmap(frame->Bitmap());
 }
 
 PassRefPtr<SharedBuffer> DeferredImageDecoder::Data() {
-  if (!rw_buffer_)
-    return nullptr;
-  sk_sp<SkROBuffer> ro_buffer(rw_buffer_->makeROBufferSnapshot());
-  RefPtr<SharedBuffer> shared_buffer = SharedBuffer::Create();
-  SkROBuffer::Iter it(ro_buffer.get());
-  do {
-    shared_buffer->Append(static_cast<const char*>(it.data()), it.size());
-  } while (it.next());
-  return shared_buffer.Release();
+  return buffer_;
 }
 
 void DeferredImageDecoder::SetData(PassRefPtr<SharedBuffer> data,
                                    bool all_data_received) {
   SetDataInternal(std::move(data), all_data_received, true);
 }
 
-void DeferredImageDecoder::SetDataInternal(RefPtr<SharedBuffer> data,
+void DeferredImageDecoder::SetDataInternal(PassRefPtr<SharedBuffer> data,
                                            bool all_data_received,
                                            bool push_data_to_decoder) {
+  buffer_ = std::move(data);
+
   if (actual_decoder_) {
     all_data_received_ = all_data_received;
     if (push_data_to_decoder)
-      actual_decoder_->SetData(data, all_data_received);
+      actual_decoder_->SetData(buffer_, all_data_received);
     PrepareLazyDecodedFrames();
   }
-
-  if (frame_generator_) {
-    if (!rw_buffer_)
-      rw_buffer_ = WTF::WrapUnique(new SkRWBuffer(data->size()));
-
-    const char* segment = 0;
-    for (size_t length = data->GetSomeData(segment, rw_buffer_->size()); length;
-         length = data->GetSomeData(segment, rw_buffer_->size())) {
-      DCHECK_GE(data->size(), rw_buffer_->size() + length);
-      const size_t remaining = data->size() - rw_buffer_->size() - length;
-      rw_buffer_->append(segment, length, remaining);
-    }
-  }
 }
 
 bool DeferredImageDecoder::IsSizeAvailable() {
   // m_actualDecoder is 0 only if image decoding is deferred and that means
   // the image header decoded successfully and the size is available.
   return actual_decoder_ ? actual_decoder_->IsSizeAvailable() : true;
 }
 
 bool DeferredImageDecoder::HasEmbeddedColorSpace() const {
   return actual_decoder_ ? actual_decoder_->HasEmbeddedColorSpace()
@@ skipping 130 matching lines @@
   }
 }
 
 sk_sp<SkImage> DeferredImageDecoder::CreateFrameImageAtIndex(
     size_t index,
     bool known_to_be_opaque) {
   const SkISize& decoded_size = frame_generator_->GetFullSize();
   DCHECK_GT(decoded_size.width(), 0);
   DCHECK_GT(decoded_size.height(), 0);
 
-  sk_sp<SkROBuffer> ro_buffer(rw_buffer_->makeROBufferSnapshot());
-  RefPtr<SegmentReader> segment_reader =
-      SegmentReader::CreateFromSkROBuffer(std::move(ro_buffer));
+  RefPtr<SharedBuffer::ThreadSafeStepper> stepper =
+      buffer_->thread_safe_stepper();
 
   SkImageInfo info = SkImageInfo::MakeN32(
       decoded_size.width(), decoded_size.height(),
       known_to_be_opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType,
       color_space_for_sk_images_);
 
   auto generator = WTF::MakeUnique<DecodingImageGenerator>(
-      frame_generator_, info, std::move(segment_reader), all_data_received_,
-      index, frame_data_[index].unique_id_);
+      frame_generator_, info, stepper, all_data_received_, index,
+      frame_data_[index].unique_id_);
   generator->SetCanYUVDecode(can_yuv_decode_);
   sk_sp<SkImage> image = SkImage::MakeFromGenerator(std::move(generator));
   if (!image)
     return nullptr;
 
   // We can consider decoded bitmap constant and reuse uniqueID only after all
   // data is received.  We reuse it also for multiframe images when image data
   // is partially received but the frame data is fully received.
   if (all_data_received_ || frame_data_[index].is_complete_) {
     DCHECK(frame_data_[index].unique_id_ ==
@@ skipping 17 matching lines @@
 
 namespace WTF {
 template <>
 struct VectorTraits<blink::DeferredFrameData>
     : public SimpleClassVectorTraits<blink::DeferredFrameData> {
   STATIC_ONLY(VectorTraits);
   static const bool kCanInitializeWithMemset =
       false;  // Not all DeferredFrameData members initialize to 0.
 };
 }