[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 150 matching lines @@
           << " @" << display_rect.x << "," << display_rect.y << " transform "
           << transform;
 
   have_video_plane_geometry_ = true;
   video_plane_display_rect_ = display_rect;
   video_plane_transform_ = transform;
 
   MaybeRunSetGeometry();
 }
 
+void VideoPlaneController::ResetGeometry() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  MaybeRunSetGeometry();
+}
+
 void VideoPlaneController::SetDeviceResolution(const Size& resolution) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(ResolutionSizeValid(resolution));
   if (have_output_res_ && SizeEqual(resolution, output_res_)) {
     VLOG(2) << "No change found in output resolution.";
     return;
   }
 
   VLOG(1) << "New output resolution " << resolution.width << "x"
           << resolution.height;
@@ skipping 14 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_;
+}
+
 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