[Chromecast] Adding pause/resume operations to VideoPlaneController.

chromecast/media/base/video_plane_controller.cc

 // Copyright 2015 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 "chromecast/media/base/video_plane_controller.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 184 matching lines @@
 
   VLOG(1) << "New graphics resolution " << resolution.width << "x"
           << resolution.height;
 
   have_graphics_res_ = true;
   graphics_res_ = resolution;
 
   MaybeRunSetGeometry();
 }
 
+void VideoPlaneController::Pause() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  VLOG(1) << "Pausing controller. No more VideoPlane SetGeometry calls.";
+  is_paused_ = true;
+}
+
+void VideoPlaneController::Resume() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  VLOG(1) << "Resuming controller. VideoPlane SetGeometry calls are active.";
+  is_paused_ = false;
+}
+
+bool VideoPlaneController::is_paused() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return is_paused_;
+}
+
+void VideoPlaneController::ClearGeometryState() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  have_video_plane_geometry_ = false;
+  video_plane_display_rect_ = RectF(0, 0, 0, 0);
+  video_plane_transform_ = VideoPlane::TRANSFORM_NONE;
+}

[halliwell, 2015/12/17 14:46:31]

So ... it looks like from the internal CL that when we get resources back, we
ClearGeometryState and Resume.  That does not sound right to me as it depends on
receiving further SetGeometry calls, which may be true in some cases but not
necessarily always.

I was expecting that we would want to keep previously cached video plane
geometry, and to post a SetGeometry call to VideoPlane at this point to
re-establish that VideoPlane's state matches VideoPlaneController.

[esum, 2015/12/21 00:39:21]

Done.

+
 VideoPlaneController::VideoPlaneController()
-    : have_output_res_(false),
+    : is_paused_(false),
+      have_output_res_(false),
       have_graphics_res_(false),
       output_res_(0, 0),
       graphics_res_(0, 0),
       have_video_plane_geometry_(false),
       video_plane_display_rect_(0, 0),
       video_plane_transform_(VideoPlane::TRANSFORM_NONE),
       media_task_runner_(MediaMessageLoop::GetTaskRunner()),
       video_plane_wrapper_(
           new RateLimitedSetVideoPlaneGeometry(media_task_runner_)) {}
 
 VideoPlaneController::~VideoPlaneController() {}
 
 void VideoPlaneController::MaybeRunSetGeometry() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!HaveDataForSetGeometry())
+  if (is_paused_) {
+    VLOG(2) << "All VideoPlane SetGeometry calls are paused. Ignoring request.";
     return;
+  }
+
+  if (!HaveDataForSetGeometry()) {
+    VLOG(2) << "Don't have all VideoPlane SetGeometry data. Ignoring request.";
+    return;
+  }
 
   DCHECK(graphics_res_.width != 0 && graphics_res_.height != 0);
 
   RectF scaled_rect = video_plane_display_rect_;
   if (graphics_res_.width != output_res_.width ||
       graphics_res_.height != output_res_.height) {
     float sx = static_cast<float>(output_res_.width) / graphics_res_.width;
     float sy = static_cast<float>(output_res_.height) / graphics_res_.height;
     scaled_rect.x *= sx;
     scaled_rect.y *= sy;
     scaled_rect.width *= sx;
     scaled_rect.height *= sy;
   }
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RateLimitedSetVideoPlaneGeometry::SetGeometry,
                  video_plane_wrapper_, scaled_rect, video_plane_transform_));
 }
 
 bool VideoPlaneController::HaveDataForSetGeometry() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return have_output_res_ && have_graphics_res_ && have_video_plane_geometry_;
 }
 
 }  // namespace media
 }  // namespace chromecast