services/ui: Detect when a video is playing

services/ui/ws/frame_generator.cc

 // Copyright 2016 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 "services/ui/ws/frame_generator.h"
 
 #include "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 55 matching lines @@
   draw_timer_.Start(
       FROM_HERE, base::TimeDelta(),
       base::Bind(&FrameGenerator::Draw, weak_factory_.GetWeakPtr()));
 }
 
 void FrameGenerator::Draw() {
   if (!delegate_->GetRootWindow()->visible())
     return;
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
+  bool old_contains_video = may_contain_video_;
   cc::CompositorFrame frame(GenerateCompositorFrame());
+  if (old_contains_video != may_contain_video_) {
+    // TODO(sad): Schedule notifying observers.
+  }
   frame_pending_ = true;
   if (display_compositor_) {
     display_compositor_->SubmitCompositorFrame(
         std::move(frame),
         base::Bind(&FrameGenerator::DidDraw, weak_factory_.GetWeakPtr()));
   }
+  if (may_contain_video_) {
+    // TODO(sad): Start a timer to reset the bit if no new frame with video
+    // is submitted 'soon'.
+  }
   dirty_rect_ = gfx::Rect();
 }
 
 void FrameGenerator::DidDraw() {
   frame_pending_ = false;
   delegate_->OnCompositorFrameDrawn();
   if (!dirty_rect_.IsEmpty())
     WantToDraw();
 }
 
 cc::CompositorFrame FrameGenerator::GenerateCompositorFrame() {
   const ViewportMetrics& metrics = delegate_->GetViewportMetrics();
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
   gfx::Rect output_rect(metrics.size_in_pixels);
   dirty_rect_.Intersect(output_rect);
   const cc::RenderPassId render_pass_id(1, 1);
   render_pass->SetNew(render_pass_id, output_rect, dirty_rect_,
                       gfx::Transform());
 
+  may_contain_video_ = false;
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  1.0f);
 
   std::unique_ptr<cc::DelegatedFrameData> frame_data(
       new cc::DelegatedFrameData);
   frame_data->render_pass_list.push_back(std::move(render_pass));
   if (delegate_->IsInHighContrastMode()) {
     std::unique_ptr<cc::RenderPass> invert_pass = cc::RenderPass::Create();
     invert_pass->SetNew(cc::RenderPassId(2, 0), output_rect, dirty_rect_,
                         gfx::Transform());
     cc::SharedQuadState* shared_state =
         invert_pass->CreateAndAppendSharedQuadState();
     shared_state->SetAll(gfx::Transform(), output_rect.size(), output_rect,
                          output_rect, false, 1.f, SkXfermode::kSrcOver_Mode, 0);
     auto* quad = invert_pass->CreateAndAppendDrawQuad<cc::RenderPassDrawQuad>();
     cc::FilterOperations filters;
     filters.Append(cc::FilterOperation::CreateInvertFilter(1.f));
     quad->SetNew(shared_state, output_rect, output_rect, render_pass_id,
                  0 /* mask_resource_id */, gfx::Vector2dF() /* mask_uv_scale */,
                  gfx::Size() /* mask_texture_size */, filters,
                  gfx::Vector2dF() /* filters_scale */,
                  cc::FilterOperations() /* background_filters */);
     frame_data->render_pass_list.push_back(std::move(invert_pass));
   }
 
   cc::CompositorFrame frame;
   frame.delegated_frame_data = std::move(frame_data);
+  frame.metadata.may_contain_video = may_contain_video_;
   return frame;
 }
 
 void FrameGenerator::DrawWindowTree(
     cc::RenderPass* pass,
     ServerWindow* window,
     const gfx::Vector2d& parent_to_root_origin_offset,
     float opacity) {
   if (!window->visible())
     return;
@@ skipping 33 matching lines @@
                 bounds_at_origin.size() /* layer_bounds */,
                 bounds_at_origin /* visible_layer_bounds */,
                 bounds_at_origin /* clip_rect */, false /* is_clipped */,
                 combined_opacity, SkXfermode::kSrcOver_Mode,
                 0 /* sorting-context_id */);
     auto quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
     quad->SetAll(sqs, bounds_at_origin /* rect */,
                  gfx::Rect() /* opaque_rect */,
                  bounds_at_origin /* visible_rect */, true /* needs_blending*/,
                  default_surface->id());
+    if (default_surface->may_contain_video())
+      may_contain_video_ = true;
   }
   if (underlay_surface) {
     const gfx::Rect underlay_absolute_bounds =
         absolute_bounds - window->underlay_offset();
     gfx::Transform quad_to_target_transform;
     quad_to_target_transform.Translate(underlay_absolute_bounds.x(),
                                        underlay_absolute_bounds.y());
     cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
     const gfx::Rect bounds_at_origin(
         underlay_surface->last_submitted_frame_size());
     sqs->SetAll(quad_to_target_transform,
                 bounds_at_origin.size() /* layer_bounds */,
                 bounds_at_origin /* visible_layer_bounds */,
                 bounds_at_origin /* clip_rect */, false /* is_clipped */,
                 combined_opacity, SkXfermode::kSrcOver_Mode,
                 0 /* sorting-context_id */);
 
     auto quad = pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
     quad->SetAll(sqs, bounds_at_origin /* rect */,
                  gfx::Rect() /* opaque_rect */,
                  bounds_at_origin /* visible_rect */, true /* needs_blending*/,
                  underlay_surface->id());
+    DCHECK(!underlay_surface->may_contain_video());
   }
 }
 
 }  // namespace ws
 
 }  // namespace ui