Allow shaped-desktop hosts to send shape only when it changes.

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"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/base/util.h"
-#include "remoting/client/frame_consumer.h"
+#include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
 #include "remoting/protocol/session_config.h"
 #include "third_party/libyuv/include/libyuv/convert_argb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using base::Passed;
 using remoting::protocol::ChannelConfig;
 using remoting::protocol::SessionConfig;
@@ skipping 46 matching lines @@
   }
 
  private:
   scoped_ptr<VideoDecoder> parent_;
 };
 
 class SoftwareVideoRenderer::Core {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
        scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-       scoped_refptr<FrameConsumerProxy> consumer);
+       scoped_ptr<FrameConsumerProxy> consumer);
   ~Core();
 
   void OnSessionConfig(const protocol::SessionConfig& config);
   void DrawBuffer(webrtc::DesktopFrame* buffer);
   void InvalidateRegion(const webrtc::DesktopRegion& region);
   void RequestReturnBuffers(const base::Closure& done);
   void SetOutputSizeAndClip(
       const webrtc::DesktopSize& view_size,
       const webrtc::DesktopRect& clip_area);
 
   // Decodes the contents of |packet|. DecodePacket may keep a reference to
   // |packet| so the |packet| must remain alive and valid until |done| is
   // executed.
   void DecodePacket(scoped_ptr<VideoPacket> packet, const base::Closure& done);
 
  private:
   // Paints the invalidated region to the next available buffer and returns it
   // to the consumer.
   void SchedulePaint();
   void DoPaint();
 
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner_;
-  scoped_refptr<FrameConsumerProxy> consumer_;
+  scoped_ptr<FrameConsumerProxy> consumer_;
   scoped_ptr<VideoDecoder> decoder_;
 
   // Remote screen size in pixels.
   webrtc::DesktopSize source_size_;
 
   // Vertical and horizontal DPI of the remote screen.
   webrtc::DesktopVector source_dpi_;
 
   // The current dimensions of the frame consumer view.
   webrtc::DesktopSize view_size_;
   webrtc::DesktopRect clip_area_;
 
   // The drawing buffers supplied by the frame consumer.
   std::list<webrtc::DesktopFrame*> buffers_;
 
   // Flag used to coalesce runs of SchedulePaint()s into a single DoPaint().
   bool paint_scheduled_;
 
   base::WeakPtrFactory<Core> weak_factory_;
 };
 
 SoftwareVideoRenderer::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-    scoped_refptr<FrameConsumerProxy> consumer)
+    scoped_ptr<FrameConsumerProxy> consumer)
     : main_task_runner_(main_task_runner),
       decode_task_runner_(decode_task_runner),
-      consumer_(consumer),
+      consumer_(consumer.Pass()),
       paint_scheduled_(false),
       weak_factory_(this) {
 }
 
 SoftwareVideoRenderer::Core::~Core() {
 }
 
 void SoftwareVideoRenderer::Core::OnSessionConfig(const SessionConfig& config) {
   DCHECK(decode_task_runner_->BelongsToCurrentThread());
 
@@ skipping 89 matching lines @@
   // Draw the invalidated region to the buffer.
   webrtc::DesktopFrame* buffer = buffers_.front();
   webrtc::DesktopRegion output_region;
   decoder_->RenderFrame(view_size_, clip_area_,
                         buffer->data(), buffer->stride(), &output_region);
 
   // Notify the consumer that painting is done.
   if (!output_region.is_empty()) {
     buffers_.pop_front();
     consumer_->ApplyBuffer(view_size_, clip_area_, buffer, output_region,
-                           *decoder_->GetImageShape());
+                           decoder_->GetImageShape());
   }
 }
 
 void SoftwareVideoRenderer::Core::RequestReturnBuffers(
     const base::Closure& done) {
   DCHECK(decode_task_runner_->BelongsToCurrentThread());
 
   while (!buffers_.empty()) {
     consumer_->ReturnBuffer(buffers_.front());
     buffers_.pop_front();
@@ skipping 52 matching lines @@
       }
     }
 
     SchedulePaint();
   }
 }
 
 SoftwareVideoRenderer::SoftwareVideoRenderer(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
-    scoped_refptr<FrameConsumerProxy> consumer)
+    FrameConsumer* frame_consumer)
     : decode_task_runner_(decode_task_runner),
-      core_(new Core(main_task_runner, decode_task_runner, consumer)),
       latest_event_timestamp_(0),
+      weak_frame_consumer_(frame_consumer),
       weak_factory_(this) {
   DCHECK(CalledOnValidThread());
+  core_ = make_scoped_ptr(new Core(main_task_runner, decode_task_runner,
+                                   make_scoped_ptr(new FrameConsumerProxy(
+                                       weak_frame_consumer_.GetWeakPtr()))));
 }
 
 SoftwareVideoRenderer::~SoftwareVideoRenderer() {
   DCHECK(CalledOnValidThread());
   bool result = decode_task_runner_->DeleteSoon(FROM_HERE, core_.release());
   DCHECK(result);
 }
 
 void SoftwareVideoRenderer::OnSessionConfig(
     const protocol::SessionConfig& config) {
@@ skipping 87 matching lines @@
   DCHECK(CalledOnValidThread());
 
   // Record the latency between the packet being received and presented.
   stats_.video_decode_ms()->Record(
       (base::Time::Now() - decode_start).InMilliseconds());
 
   done.Run();
 }
 
 }  // namespace remoting