Remove FrameGenerator::root_window_

services/ui/ws/frame_generator.h

 // 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.
 
 #ifndef SERVICES_UI_WS_FRAME_GENERATOR_H_
 #define SERVICES_UI_WS_FRAME_GENERATOR_H_
 
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 10 matching lines @@
 #include "ui/gfx/native_widget_types.h"
 
 namespace cc {
 class CompositorFrameSink;
 class RenderPass;
 }
 
 namespace ui {
 namespace ws {
 
-class ServerWindow;
-
 // Responsible for redrawing the display in response to the redraw requests by
 // submitting CompositorFrames to the owned CompositorFrameSink.
 class FrameGenerator : public cc::CompositorFrameSinkClient,
                        public cc::BeginFrameObserver {
  public:
-  FrameGenerator(
-      ServerWindow* root_window,
-      std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink);
+  FrameGenerator(std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink,
+                 bool visible,

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

Hmm, we don't do this for device_scale_factor... Maybe just call these AFTER
creating FrameGenerator for the sake of consistency?

[Alex Z., 2017/03/22 13:17:17]

I did it this way to preserve the same behavior. Changing visibility or window
bounds triggers BeginFrames. Initializing them in the 
constructor makes sure that they stay consistent with the root window 
without requesting more BeginFrames than it currently does. 

Setting them after creation (like what we do with device scale factor) 
could result in FrameGenerator getting 2 more BeginFrames. Are we OK
with that?

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

Done.

+                 const gfx::Rect& bounds);
   ~FrameGenerator() override;
 
   void SetDeviceScaleFactor(float device_scale_factor);
   void SetHighContrastMode(bool enabled);
 
   // Updates the WindowManager's SurfaceInfo.
   void OnSurfaceCreated(const cc::SurfaceInfo& surface_info);
 
   void OnWindowDamaged();
+  void OnWindowVisibilityChanged(bool visible);
+  void OnWindowBoundsChanged(const gfx::Rect& bounds);
 
  private:
   // cc::CompositorFrameSinkClient implementation:
   void SetBeginFrameSource(cc::BeginFrameSource* source) override;
   void ReclaimResources(const cc::ReturnedResourceArray& resources) override;
   void SetTreeActivationCallback(const base::Closure& callback) override;
   void DidReceiveCompositorFrameAck() override;
   void DidLoseCompositorFrameSink() override;
   void OnDraw(const gfx::Transform& transform,
               const gfx::Rect& viewport,
               bool resourceless_software_draw) override;
   void SetMemoryPolicy(const cc::ManagedMemoryPolicy& policy) override;
   void SetExternalTilePriorityConstraints(
       const gfx::Rect& viewport_rect,
       const gfx::Transform& transform) override;
 
   // cc::BeginFrameObserver implementation:
   void OnBeginFrame(const cc::BeginFrameArgs& args) override;
   const cc::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
   void OnBeginFrameSourcePausedChanged(bool paused) override;
 
   // Generates the CompositorFrame.
-  cc::CompositorFrame GenerateCompositorFrame(const gfx::Rect& output_rect);
+  cc::CompositorFrame GenerateCompositorFrame();
 
   // DrawWindow creates SurfaceDrawQuad for the window manager and appends it to
   // the provided cc::RenderPass.
   void DrawWindow(cc::RenderPass* pass);
 
   // SetNeedsBeginFrame sets observing_begin_frames_ and add/remove
   // FrameGenerator as an observer to/from begin_frame_source_ accordingly.
   void SetNeedsBeginFrame(bool needs_begin_frame);
 
-  ServerWindow* const root_window_;
   float device_scale_factor_ = 1.f;
+  bool is_window_visible_;
+  gfx::Rect bounds_;
 
   std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink_;
   cc::BeginFrameArgs last_begin_frame_args_;
   cc::BeginFrameSource* begin_frame_source_ = nullptr;
   bool observing_begin_frames_ = false;
   bool high_contrast_mode_enabled_ = false;
 
   cc::SurfaceInfo window_manager_surface_info_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameGenerator);
 };
 
 }  // namespace ws
 
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_FRAME_GENERATOR_H_