Remove FrameGenerator::root_window_

services/ui/ws/frame_generator.cc

Index: services/ui/ws/frame_generator.cc
diff --git a/services/ui/ws/frame_generator.cc b/services/ui/ws/frame_generator.cc
index 87f0f1426288ac97294c4ec076df3ff790c908b7..62147dc5147d886f5d19b21ba158bd4ad4ad124e 100644
--- a/services/ui/ws/frame_generator.cc
+++ b/services/ui/ws/frame_generator.cc
@@ -13,16 +13,17 @@
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
-#include "services/ui/ws/server_window.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(
-    ServerWindow* root_window,
-    std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink)
-    : root_window_(root_window),
+    std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink,
+    bool visible,
+    const gfx::Rect& bounds)
+    : is_window_visible_(visible),
+      bounds_(bounds),
       compositor_frame_sink_(std::move(compositor_frame_sink)) {
   compositor_frame_sink_->BindToClient(this);
 }
@@ -64,6 +65,24 @@ void FrameGenerator::OnWindowDamaged() {
     SetNeedsBeginFrame(true);
 }
 
+void FrameGenerator::OnWindowVisibilityChanged(bool visible) {
+  if (visible == is_window_visible_)
+    return;
+
+  is_window_visible_ = visible;
+  if (visible && window_manager_surface_info_.is_valid())

[Fady Samuel, 2017/03/22 03:38:38]

SetNeedsBeginFrame(visible)?

[Alex Z., 2017/03/22 14:56:43]

Done.

+    SetNeedsBeginFrame(true);

[Fady Samuel, 2017/03/22 03:38:38]

You know, maybe we should move window_manager_surface_info_ into
SetNeedsBeginFrame(..)?

[Alex Z., 2017/03/22 14:56:43]

Done.

+}
+
+void FrameGenerator::OnWindowBoundsChanged(const gfx::Rect& bounds) {
+  if (bounds == bounds_)
+    return;
+
+  bounds_ = bounds;
+  if (window_manager_surface_info_.is_valid())
+    SetNeedsBeginFrame(true);

[Fady Samuel, 2017/03/22 03:38:39]

SetNeedsBeginFrame(true);

+}
+
 void FrameGenerator::SetBeginFrameSource(cc::BeginFrameSource* source) {
   if (begin_frame_source_ && observing_begin_frames_)
     begin_frame_source_->RemoveObserver(this);
@@ -98,13 +117,12 @@ void FrameGenerator::SetExternalTilePriorityConstraints(
     const gfx::Transform& transform) {}
 
 void FrameGenerator::OnBeginFrame(const cc::BeginFrameArgs& begin_frame_args) {
-  if (!root_window_->visible() ||
-      begin_frame_args.type == cc::BeginFrameArgs::MISSED) {
+  if (begin_frame_args.type == cc::BeginFrameArgs::MISSED) {
     return;
   }
 
   // TODO(fsamuel): We should add a trace for generating a top level frame.
-  cc::CompositorFrame frame(GenerateCompositorFrame(root_window_->bounds()));
+  cc::CompositorFrame frame(GenerateCompositorFrame());
 
   compositor_frame_sink_->SubmitCompositorFrame(std::move(frame));
   SetNeedsBeginFrame(false);
@@ -117,12 +135,10 @@ const cc::BeginFrameArgs& FrameGenerator::LastUsedBeginFrameArgs() const {
 
 void FrameGenerator::OnBeginFrameSourcePausedChanged(bool paused) {}
 
-cc::CompositorFrame FrameGenerator::GenerateCompositorFrame(
-    const gfx::Rect& output_rect) {
+cc::CompositorFrame FrameGenerator::GenerateCompositorFrame() {
   const int render_pass_id = 1;
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
-  render_pass->SetNew(render_pass_id, output_rect, output_rect,
-                      gfx::Transform());
+  render_pass->SetNew(render_pass_id, bounds_, bounds_, gfx::Transform());
 
   DrawWindow(render_pass.get());
 
@@ -130,18 +146,18 @@ cc::CompositorFrame FrameGenerator::GenerateCompositorFrame(
   frame.render_pass_list.push_back(std::move(render_pass));
   if (high_contrast_mode_enabled_) {
     std::unique_ptr<cc::RenderPass> invert_pass = cc::RenderPass::Create();
-    invert_pass->SetNew(2, output_rect, output_rect, gfx::Transform());
+    invert_pass->SetNew(2, bounds_, bounds_, gfx::Transform());
     cc::SharedQuadState* shared_state =
         invert_pass->CreateAndAppendSharedQuadState();
     gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(
-        output_rect.size(), window_manager_surface_info_.device_scale_factor(),
+        bounds_.size(), window_manager_surface_info_.device_scale_factor(),
         window_manager_surface_info_.device_scale_factor());
-    shared_state->SetAll(gfx::Transform(), scaled_bounds, output_rect,
-                         output_rect, false, 1.f, SkBlendMode::kSrcOver, 0);
+    shared_state->SetAll(gfx::Transform(), scaled_bounds, bounds_, bounds_,
+                         false, 1.f, SkBlendMode::kSrcOver, 0);
     auto* quad = invert_pass->CreateAndAppendDrawQuad<cc::RenderPassDrawQuad>();
     frame.render_pass_list.back()->filters.Append(
         cc::FilterOperation::CreateInvertFilter(1.f));
-    quad->SetNew(shared_state, output_rect, output_rect, render_pass_id,
+    quad->SetNew(shared_state, bounds_, bounds_, render_pass_id,
                  0 /* mask_resource_id */, gfx::RectF() /* mask_uv_rect */,
                  gfx::Size() /* mask_texture_size */,
                  gfx::Vector2dF() /* filters_scale */,
@@ -191,7 +207,7 @@ void FrameGenerator::DrawWindow(cc::RenderPass* pass) {
 }
 
 void FrameGenerator::SetNeedsBeginFrame(bool needs_begin_frame) {
-  if (needs_begin_frame == observing_begin_frames_)
+  if (!is_window_visible_ || needs_begin_frame == observing_begin_frames_)

[Fady Samuel, 2017/03/22 03:38:39]

This isn't quite right...

needs_begin_frame &= is_window_visible_;
if (needs_begin_frame == observing_begin_frames_)
  ...

[Alex Z., 2017/03/22 14:56:43]

Done.

     return;
 
   observing_begin_frames_ = needs_begin_frame;