Remove FrameGenerator::root_window_

services/ui/ws/platform_display_default.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/platform_display_default.h"
 
 #include "base/memory/ptr_util.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/display/screen_manager.h"
 #include "services/ui/ws/display_client_compositor_frame_sink.h"
@@ skipping 19 matching lines @@
 namespace ws {
 
 PlatformDisplayDefault::PlatformDisplayDefault(
     ServerWindow* root_window,
     const display::ViewportMetrics& metrics)
     : root_window_(root_window),
 #if !defined(OS_ANDROID)
       image_cursors_(new ImageCursors),
 #endif
       metrics_(metrics),
-      widget_(gfx::kNullAcceleratedWidget),
-      init_device_scale_factor_(metrics.device_scale_factor) {
+      widget_(gfx::kNullAcceleratedWidget) {
+  root_window_->AddObserver(this);
 }
 
 PlatformDisplayDefault::~PlatformDisplayDefault() {
+  root_window_->RemoveObserver(this);
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
   frame_generator_.reset();
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state. But destroy the surface
   // first because it can still be using the platform window.
   platform_window_.reset();
 }
 
@@ skipping 195 matching lines @@
       widget_, mojo::MakeRequest(&compositor_frame_sink),
       std::move(compositor_frame_sink_client),
       mojo::MakeRequest(&display_private));
 
   auto display_client_compositor_frame_sink =
       base::MakeUnique<DisplayClientCompositorFrameSink>(
           root_window_->frame_sink_id(), std::move(compositor_frame_sink),
           std::move(display_private),
           std::move(compositor_frame_sink_client_request));
   frame_generator_ = base::MakeUnique<FrameGenerator>(
-      root_window_, std::move(display_client_compositor_frame_sink));
-  frame_generator_->SetDeviceScaleFactor(init_device_scale_factor_);
+      std::move(display_client_compositor_frame_sink));
+  frame_generator_->OnWindowVisibilityChanged(root_window_->visible());
+  frame_generator_->OnWindowBoundsChanged(root_window_->bounds());
+  frame_generator_->SetDeviceScaleFactor(metrics_.device_scale_factor);
 }
 
 void PlatformDisplayDefault::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void PlatformDisplayDefault::OnActivationChanged(bool active) {}
 
+void PlatformDisplayDefault::OnWindowBoundsChanged(

[msw, 2017/03/22 19:36:52]

Why not make FrameGenerator observe the ServerWindow directly?
(it seems odd to make PlatformDisplayDefault forward these calls)

[Alex Z., 2017/03/22 20:51:10]

We wanted to make FrameGenerator as simple as possible.

After some offline discussion, we decided to update bounds in 
PlatformDisplayDefault::UpdateViewportMetrics() and remove 
FrameGenerator::is_window_visible_.

+    ServerWindow* window,
+    const gfx::Rect& old_bounds,
+    const gfx::Rect& new_bounds) {
+  if (frame_generator_)
+    frame_generator_->OnWindowBoundsChanged(new_bounds);
+}
+
+void PlatformDisplayDefault::OnWindowVisibilityChanged(ServerWindow* window) {
+  if (frame_generator_)
+    frame_generator_->OnWindowVisibilityChanged(window->visible());
+}
+
 }  // namespace ws
 }  // namespace ui