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

remoting/client/plugin/pepper_video_renderer_2d.cc

 // Copyright (c) 2012 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/plugin/pepper_video_renderer_2d.h"
 
 #include <functional>
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/size.h"
 #include "remoting/base/util.h"
 #include "remoting/client/chromoting_stats.h"
 #include "remoting/client/client_context.h"
-#include "remoting/client/frame_consumer_proxy.h"
 #include "remoting/client/frame_producer.h"
 #include "remoting/client/software_video_renderer.h"
 #include "remoting/proto/video.pb.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace {
 
 // DesktopFrame that wraps a supplied pp::ImageData
 class PepperDesktopFrame : public webrtc::DesktopFrame {
  public:
@@ skipping 30 matching lines @@
 
 PepperVideoRenderer2D::PepperVideoRenderer2D()
     : instance_(nullptr),
       event_handler_(nullptr),
       merge_buffer_(nullptr),
       dips_to_device_scale_(1.0f),
       dips_to_view_scale_(1.0f),
       flush_pending_(false),
       frame_received_(false),
       debug_dirty_region_(false),
-      callback_factory_(this),
-      weak_factory_(this) {
+      callback_factory_(this) {
 }
 
 PepperVideoRenderer2D::~PepperVideoRenderer2D() {
   // The producer should now return any pending buffers. At this point, however,
   // ReturnBuffer() tasks scheduled by the producer will not be delivered,
   // so we free all the buffers once the producer's queue is empty.
   base::WaitableEvent done_event(true, false);
   software_video_renderer_->RequestReturnBuffers(
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done_event)));
   done_event.Wait();
 
   merge_buffer_ = nullptr;
   while (!buffers_.empty()) {
     FreeBuffer(buffers_.front());
   }
 }
 
 bool PepperVideoRenderer2D::Initialize(pp::Instance* instance,
                                        const ClientContext& context,
                                        EventHandler* event_handler) {
   DCHECK(CalledOnValidThread());
+  DCHECK(context.main_task_runner()->BelongsToCurrentThread());
   DCHECK(!instance_);
   DCHECK(!event_handler_);
   DCHECK(instance);
   DCHECK(event_handler);
 
   instance_ = instance;
   event_handler_ = event_handler;
-  frame_consumer_proxy_ = new FrameConsumerProxy(
-      context.main_task_runner(), weak_factory_.GetWeakPtr());
   software_video_renderer_.reset(new SoftwareVideoRenderer(
-      context.main_task_runner(), context.decode_task_runner(),
-      frame_consumer_proxy_));
+      context.main_task_runner(), context.decode_task_runner(), this));

[Sergey Ulanov, 2015/07/13 21:00:32]

I think we still need FrameConsumerProxy. SoftwareVideoRenderer calls the
consumer on the decode thread, while this class doesn't expect it.

[Wez, 2015/07/14 02:26:44]

SoftwareVideoRenderer delegates decode-thread work to an internal Core object -
the outer object is non-thread-safe, so I moved the FrameConsumerProxy inside
it, to clean up the interface.

[Sergey Ulanov, 2015/07/14 16:12:24]

I see, sorry I messed. This makes sense.

[Sergey Ulanov, 2015/07/14 16:13:22]

I meant I mIssed it.

 
   return true;
 }
 
 void PepperVideoRenderer2D::OnViewChanged(const pp::View& view) {
   DCHECK(CalledOnValidThread());
 
   bool view_changed = false;
 
   pp::Rect pp_size = view.GetRect();
@@ skipping 82 matching lines @@
 protocol::VideoStub* PepperVideoRenderer2D::GetVideoStub() {
   DCHECK(CalledOnValidThread());
 
   return software_video_renderer_->GetVideoStub();
 }
 
 void PepperVideoRenderer2D::ApplyBuffer(const webrtc::DesktopSize& view_size,
                                         const webrtc::DesktopRect& clip_area,
                                         webrtc::DesktopFrame* buffer,
                                         const webrtc::DesktopRegion& region,
-                                        const webrtc::DesktopRegion& shape) {
+                                        const webrtc::DesktopRegion* shape) {
   DCHECK(CalledOnValidThread());
 
   if (!frame_received_) {
     event_handler_->OnVideoFirstFrameReceived();
     frame_received_ = true;
   }
   // We cannot use the data in the buffer if its dimensions don't match the
   // current view size.
-  // TODO(alexeypa): We could rescale and draw it (or even draw it without
-  // rescaling) to reduce the perceived lag while we are waiting for
-  // the properly scaled data.
   if (!view_size_.equals(view_size)) {
     FreeBuffer(buffer);
     AllocateBuffers();
   } else {
     FlushBuffer(clip_area, buffer, region);
-    event_handler_->OnVideoShape(shape);
+    if (shape) {
+      if (!source_shape_ || !source_shape_->Equals(*shape)) {
+        source_shape_ = make_scoped_ptr(new webrtc::DesktopRegion(*shape));
+        event_handler_->OnVideoShape(source_shape_.get());
+      }
+    } else if (source_shape_) {
+      source_shape_ = nullptr;
+      event_handler_->OnVideoShape(nullptr);
+    }
   }
 }
 
 void PepperVideoRenderer2D::ReturnBuffer(webrtc::DesktopFrame* buffer) {
   DCHECK(CalledOnValidThread());
 
   // Reuse the buffer if it is large enough, otherwise drop it on the floor
   // and allocate a new one.
   if (buffer->size().width() >= clip_area_.width() &&
       buffer->size().height() >= clip_area_.height()) {
@@ skipping 126 matching lines @@
 
   // If there is a buffer queued for rendering then render it now.
   if (merge_buffer_) {
     buffer = merge_buffer_;
     merge_buffer_ = nullptr;
     FlushBuffer(merge_clip_area_, buffer, merge_region_);
   }
 }
 
 }  // namespace remoting