[Chromecast] Adding pause/resume operations to VideoPlaneController.

chromecast/media/base/video_plane_controller.h

 // 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.
 
 #ifndef CHROMECAST_MEDIA_VIDEO_PLANE_CONTROLLER_H_
 #define CHROMECAST_MEDIA_VIDEO_PLANE_CONTROLLER_H_
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
@@ skipping 41 matching lines @@
   // from the last call to this method, it is a no-op.
   void SetDeviceResolution(const Size& resolution);
 
   // Sets graphics hardware plane resolution.  This must be called at least once
   // when the hardware graphics plane resolution (same resolution as
   // gfx::Screen) is known, then later when it changes. If there is no change to
   // the graphics plane resolution from the last call to this method, it is a
   // no-op.
   void SetGraphicsPlaneResolution(const Size& resolution);
 
+  // After Pause is called, no further calls to VideoPlane::SetGeometry will be
+  // made except for any pending calls already scheduled on the media thread.

[halliwell, 2016/01/12 03:25:07]

Technically, doesn't this mean we're not implementing resource relinquish
correctly?  I.e. we could be saying we've relinquished when there are some
pending calls still?

We could probably follow up on that separately given this addresses the resume
behaviour.

[esum, 2016/01/12 04:51:47]

Ah, so I wasn't sure if this was worth the extra code, but it sounds like it is.
What actually happens if a couple SetGeometry calls on the media thread slip
through after the OEM revokes resources? Is it just implementation dependent?

To fix, my first thought is Pause/Resume become asynchronous, so
CastResource::Acquire/RevokeResource are asynchronous, which complicates the
logic in ResourceManagerImpl even more.

[halliwell, 2016/01/12 15:40:38]

It is implementation-dependent, yes.  I don't think it is worth holding up this
change though.  Remember that we currently don't handle media resource
relinquish in a fine-grained way at all.  In order to release video decoder
resources, we just stop the current application.
I think we should leave this issue for now, but add a TODO.

[esum, 2016/01/15 23:02:28]

Done.

+  // The Set methods will however update cached parameters that will take
+  // effect once the class is resumed. Safe to call multiple times.
+  void Pause();
+  // Makes class active again. Also resets the video plane by posting a call to
+  // VideoPlane::SetGeometry with most recent resolution and geometry parameters
+  // (assuming they are all set). Safe to call multiple times.
+  void Resume();
+  bool is_paused() const;
+
  private:
   class RateLimitedSetVideoPlaneGeometry;
   friend struct base::DefaultSingletonTraits<VideoPlaneController>;
 
   VideoPlaneController();
   ~VideoPlaneController();
 
   // Check if HaveDataForSetGeometry. If not, this method is a no-op. Otherwise
   // it scales the display rect from graphics to device resolution coordinates.
   // Then posts task to media thread for VideoPlane::SetGeometry.
   void MaybeRunSetGeometry();
   // Checks if all data has been collected to make calls to
   // VideoPlane::SetGeometry.
   bool HaveDataForSetGeometry() const;
 
+  bool is_paused_;
+
   // Current resolutions
   bool have_output_res_;
   bool have_graphics_res_;
   Size output_res_;
   Size graphics_res_;
 
   // Saved video plane parameters (in graphics plane coordinates)
   // for use when screen resolution changes.
   bool have_video_plane_geometry_;
   RectF video_plane_display_rect_;
   VideoPlane::Transform video_plane_transform_;
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   scoped_refptr<RateLimitedSetVideoPlaneGeometry> video_plane_wrapper_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoPlaneController);
 };
 
 }  // namespace media
 }  // namespace chromecast
 
 #endif  // CHROMECAST_MEDIA_VIDEO_PLANE_CONTROLLER_H_