Remove VideoDecoder::Initialize().

remoting/client/software_video_renderer.cc

 // Copyright 2014 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.
 
 #include "remoting/client/software_video_renderer.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 19 matching lines @@
 // This class wraps a VideoDecoder and byte-swaps the pixels for compatibility
 // with the android.graphics.Bitmap class.
 // TODO(lambroslambrou): Refactor so that the VideoDecoder produces data
 // in the right byte-order, instead of swapping it here.
 class RgbToBgrVideoDecoderFilter : public VideoDecoder {
  public:
   RgbToBgrVideoDecoderFilter(scoped_ptr<VideoDecoder> parent)
       : parent_(parent.Pass()) {
   }
 
-  void Initialize(const webrtc::DesktopSize& screen_size) override {
-    parent_->Initialize(screen_size);
-  }
-
   bool DecodePacket(const VideoPacket& packet) override {
     return parent_->DecodePacket(packet);
   }
 
   void Invalidate(const webrtc::DesktopSize& view_size,
                   const webrtc::DesktopRegion& region) override {
     return parent_->Invalidate(view_size, region);
   }
 
   void RenderFrame(const webrtc::DesktopSize& view_size,
@@ skipping 104 matching lines @@
     scoped_ptr<VideoDecoder> wrapper(
         new RgbToBgrVideoDecoderFilter(decoder_.Pass()));
     decoder_ = wrapper.Pass();
   }
 }
 
 void SoftwareVideoRenderer::Core::DecodePacket(scoped_ptr<VideoPacket> packet,
                                                 const base::Closure& done) {
   DCHECK(decode_task_runner_->BelongsToCurrentThread());
 
-  bool decoder_needs_reset = false;
   bool notify_size_or_dpi_change = false;
 
   // If the packet includes screen size or DPI information, store them.
   if (packet->format().has_screen_width() &&
       packet->format().has_screen_height()) {
     webrtc::DesktopSize source_size(packet->format().screen_width(),
                                     packet->format().screen_height());
     if (!source_size_.equals(source_size)) {
       source_size_ = source_size;
-      decoder_needs_reset = true;
       notify_size_or_dpi_change = true;
     }
   }
   if (packet->format().has_x_dpi() && packet->format().has_y_dpi()) {
     webrtc::DesktopVector source_dpi(packet->format().x_dpi(),
                                      packet->format().y_dpi());
     if (!source_dpi.equals(source_dpi_)) {
       source_dpi_ = source_dpi;
       notify_size_or_dpi_change = true;
     }
   }
 
   // If we've never seen a screen size, ignore the packet.
   if (source_size_.is_empty()) {
     main_task_runner_->PostTask(FROM_HERE, base::Bind(done));
     return;
   }
 
-  if (decoder_needs_reset)
-    decoder_->Initialize(source_size_);
   if (notify_size_or_dpi_change)
     consumer_->SetSourceSize(source_size_, source_dpi_);
 
   if (decoder_->DecodePacket(*packet.get())) {
     SchedulePaint();
   } else {
     LOG(ERROR) << "DecodePacket() failed.";
   }
 
   main_task_runner_->PostTask(FROM_HERE, base::Bind(done));
@@ skipping 194 matching lines @@
   DCHECK(CalledOnValidThread());
 
   // Record the latency between the packet being received and presented.
   base::TimeDelta decode_time = base::Time::Now() - decode_start;
   stats_.RecordDecodeTime(decode_time.InMilliseconds());
 
   decode_task_runner_->PostTask(FROM_HERE, done);
 }
 
 }  // namespace remoting