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"
@@ skipping 82 matching lines @@
                                        const ClientContext& context,
                                        EventHandler* event_handler) {
   DCHECK(CalledOnValidThread());
   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());
+  scoped_ptr<FrameConsumerProxy> frame_consumer_proxy =
+      make_scoped_ptr(new FrameConsumerProxy(weak_factory_.GetWeakPtr()));
   software_video_renderer_.reset(new SoftwareVideoRenderer(
       context.main_task_runner(), context.decode_task_runner(),
-      frame_consumer_proxy_));
+      frame_consumer_proxy.Pass()));
 
   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