services/ui: Detect when a video is playing

cc/surfaces/surface_aggregator.cc

 // Copyright 2014 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 "cc/surfaces/surface_aggregator.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 684 matching lines @@
 
   CHECK(debug_weak_this.get());
   for (const auto& render_pass : frame_data->render_pass_list) {
     if (!render_pass->copy_requests.empty()) {
       RenderPassId remapped_pass_id = RemapPassId(render_pass->id, surface_id);
       copy_request_passes_.insert(remapped_pass_id);
     }
   }
 
   referenced_surfaces_.erase(it);
+  if (!damage_rect.IsEmpty() && surface_frame.metadata.may_contain_video)

[enne (OOO), 2016/07/25 19:17:35]

Why does the damage rect come into play here? If you had a 30 fps video but the
browser compositor had a tab spinner animation at 60fps, would you want the may
contain video to alternate true/false every other frame?

[sadrul, 2016/07/26 04:39:20]

Yes. The window server will need to notify observers of inactivity based on a
timeout anyway (e.g. if a video is paused, and no new frame is submitted, we
need to notify that video has stopped playing). So if the flag is toggled every
frame, that wouldn't be problematic here.

[enne (OOO), 2016/07/26 21:43:54]

Hmm, makes sense for paused videos, thanks for the explanation.

+    result->may_contain_video = true;
   return damage_rect;
 }
 
 void SurfaceAggregator::CopyUndrawnSurfaces(PrewalkResult* prewalk_result) {
   // undrawn_surfaces are Surfaces that were identified by prewalk as being
   // referenced by a drawn Surface, but aren't contained in a SurfaceDrawQuad.
   // They need to be iterated over to ensure that any copy requests on them
   // (or on Surfaces they reference) are executed.
   std::vector<SurfaceId> surfaces_to_copy(
       prewalk_result->undrawn_surfaces.begin(),
@@ skipping 64 matching lines @@
 
   dest_resource_list_ = &frame.delegated_frame_data->resource_list;
   dest_pass_list_ = &frame.delegated_frame_data->render_pass_list;
 
   valid_surfaces_.clear();
   PrewalkResult prewalk_result;
   root_damage_rect_ =
       PrewalkTree(surface_id, false, RenderPassId(), &prewalk_result);
   PropagateCopyRequestPasses();
   has_copy_requests_ = !copy_request_passes_.empty();
+  frame.metadata.may_contain_video = prewalk_result.may_contain_video;
 
   CopyUndrawnSurfaces(&prewalk_result);
   SurfaceSet::iterator it = referenced_surfaces_.insert(surface_id).first;
   CopyPasses(root_surface_frame.delegated_frame_data.get(), surface);
   referenced_surfaces_.erase(it);
 
   moved_pixel_passes_.clear();
   copy_request_passes_.clear();
   render_pass_dependencies_.clear();
 
@@ skipping 32 matching lines @@
 
 void SurfaceAggregator::SetFullDamageForSurface(const SurfaceId& surface_id) {
   auto it = previous_contained_surfaces_.find(surface_id);
   if (it == previous_contained_surfaces_.end())
     return;
   // Set the last drawn index as 0 to ensure full damage next time it's drawn.
   it->second = 0;
 }
 
 }  // namespace cc