Mus+Ash: Unified BeginFrame Skeleton

services/ui/ws/window_server.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 "services/ui/ws/window_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 196 matching lines @@
             pair.second->window_manager_state()->GetOrphanedRootWithId(id);
         if (window)
           return window;
       }
     }
   }
   WindowTree* tree = GetTreeWithId(id.client_id);
   return tree ? tree->GetWindow(id) : nullptr;
 }
 
-void WindowServer::SchedulePaint(ServerWindow* window,
-                                 const gfx::Rect& bounds) {
-  Display* display = display_manager_->GetDisplayContaining(window);
-  if (display)
-    display->SchedulePaint(window, bounds);
-}
-
 void WindowServer::OnTreeMessagedClient(ClientSpecificId id) {
   if (current_operation_)
     current_operation_->MarkTreeAsMessaged(id);
 }
 
 bool WindowServer::DidTreeMessageClient(ClientSpecificId id) const {
   return current_operation_ && current_operation_->DidMessageTree(id);
 }
 
 const WindowTree* WindowServer::GetTreeWithRoot(
@@ skipping 55 matching lines @@
       return focused_window;
   }
   return nullptr;
 }
 
 bool WindowServer::IsActiveUserInHighContrastMode() const {
   return IsUserInHighContrastMode(user_id_tracker_.active_id());
 }
 
 void WindowServer::SetHighContrastMode(const UserId& user, bool enabled) {
+  // TODO(fsamuel): This doesn't really seem like it's a window server concept?
   if (IsUserInHighContrastMode(user) == enabled)
     return;
   high_contrast_mode_[user] = enabled;
-  if (user_id_tracker_.active_id() != user)
-    return;
-  for (Display* display : display_manager_->displays()) {
-    display->SchedulePaint(display->root_window(),
-                           gfx::Rect(display->root_window()->bounds().size()));
-  }
 }
 
 uint32_t WindowServer::GenerateWindowManagerChangeId(
     WindowTree* source,
     uint32_t client_change_id) {
   const uint32_t wm_change_id = next_wm_change_id_++;
   in_flight_wm_change_map_[wm_change_id] = {source->id(), client_change_id};
   return wm_change_id;
 }
 
@@ skipping 287 matching lines @@
   mojom::Cursor cursor_id = mojom::Cursor::CURSOR_NULL;
   if (event_dispatcher->GetCurrentMouseCursor(&cursor_id))
     display_root->display()->UpdateNativeCursor(cursor_id);
 }
 
 bool WindowServer::IsUserInHighContrastMode(const UserId& user) const {
   const auto iter = high_contrast_mode_.find(user);
   return (iter == high_contrast_mode_.end()) ? false : iter->second;
 }
 
-void WindowServer::OnScheduleWindowPaint(ServerWindow* window) {
-  if (in_destructor_)
-    return;
-
-  SchedulePaint(window, gfx::Rect(window->bounds().size()));
-  if (!window_paint_callback_.is_null())
-    window_paint_callback_.Run(window);
-}
-
-const ServerWindow* WindowServer::GetRootWindow(
-    const ServerWindow* window) const {
-  const Display* display = display_manager_->GetDisplayContaining(window);
+ServerWindow* WindowServer::GetRootWindow(const ServerWindow* window) {
+  Display* display = display_manager_->GetDisplayContaining(window);
   return display ? display->root_window() : nullptr;
 }
 
 void WindowServer::OnWindowDestroyed(ServerWindow* window) {
   ProcessWindowDeleted(window);
 }
 
 void WindowServer::OnWillChangeWindowHierarchy(ServerWindow* window,
                                                ServerWindow* new_parent,
                                                ServerWindow* old_parent) {
@@ skipping 10 matching lines @@
     return;
 
   WindowManagerDisplayRoot* display_root =
       display_manager_->GetWindowManagerDisplayRoot(window);
   if (display_root)
     display_root->window_manager_state()
         ->ReleaseCaptureBlockedByAnyModalWindow();
 
   ProcessWindowHierarchyChanged(window, new_parent, old_parent);
 
-  // TODO(beng): optimize.
-  if (old_parent)
-    SchedulePaint(old_parent, gfx::Rect(old_parent->bounds().size()));
-  if (new_parent)
-    SchedulePaint(new_parent, gfx::Rect(new_parent->bounds().size()));
-
   UpdateNativeCursorFromMouseLocation(window);
 }
 
 void WindowServer::OnWindowBoundsChanged(ServerWindow* window,
                                          const gfx::Rect& old_bounds,
                                          const gfx::Rect& new_bounds) {
   if (in_destructor_)
     return;
 
   ProcessWindowBoundsChanged(window, old_bounds, new_bounds);
   if (!window->parent())
     return;
 
-  SchedulePaint(window->parent(), old_bounds);
-  SchedulePaint(window->parent(), new_bounds);
-
   UpdateNativeCursorFromMouseLocation(window);
 }
 
 void WindowServer::OnWindowClientAreaChanged(
     ServerWindow* window,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas) {
   if (in_destructor_)
     return;
 
   ProcessClientAreaChanged(window, new_client_area,
                            new_additional_client_areas);
 
   UpdateNativeCursorIfOver(window);
 }
 
 void WindowServer::OnWindowReordered(ServerWindow* window,
                                      ServerWindow* relative,
                                      mojom::OrderDirection direction) {
   ProcessWindowReorder(window, relative, direction);
-  if (!in_destructor_)
-    SchedulePaint(window, gfx::Rect(window->bounds().size()));
   UpdateNativeCursorFromMouseLocation(window);
 }
 
 void WindowServer::OnWillChangeWindowVisibility(ServerWindow* window) {
   if (in_destructor_)
     return;
 
-  // Need to repaint if the window was drawn (which means it's in the process of
-  // hiding) or the window is transitioning to drawn.
-  if (window->parent() &&
-      (window->IsDrawn() ||
-       (!window->visible() && window->parent()->IsDrawn()))) {
-    SchedulePaint(window->parent(), window->bounds());
-  }
-
   for (auto& pair : tree_map_) {
     pair.second->ProcessWillChangeWindowVisibility(
         window, IsOperationSource(pair.first));
   }
 }
 
 void WindowServer::OnWindowOpacityChanged(ServerWindow* window,
                                           float old_opacity,
                                           float new_opacity) {
   DCHECK(!in_destructor_);
@@ skipping 89 matching lines @@
   // If the window doesn't have a parent then we have nothing to propagate.
   if (!window)
     return;
 
   // Cache the last submitted surface ID in the window server.
   // DisplayCompositorFrameSink may submit a CompositorFrame without
   // creating a CompositorFrameSinkManager.
   window->GetOrCreateCompositorFrameSinkManager()->SetLatestSurfaceInfo(
       compositor_frame_sink_type, surface_id, frame_size);
 
+  // This is only used for testing to observe that a window has a
+  // CompositorFrame.
+  if (!window_paint_callback_.is_null())
+    window_paint_callback_.Run(window);
+
   // We only care about propagating default surface IDs.
   // TODO(fsamuel, sadrul): we should get rid of CompositorFrameSinkTypes.
   if (compositor_frame_sink_type != mojom::CompositorFrameSinkType::DEFAULT ||
       !window->parent()) {
     return;
   }
   WindowTree* window_tree = GetTreeWithId(window->parent()->id().client_id);
   if (window_tree) {
     window_tree->ProcessWindowSurfaceChanged(window, surface_id, frame_size,
                                              device_scale_factor);
   }
 }
 
 void WindowServer::OnActiveUserIdChanged(const UserId& previously_active_id,
                                          const UserId& active_id) {
-  if (IsUserInHighContrastMode(previously_active_id) ==
-      IsUserInHighContrastMode(active_id))
-    return;
-  for (Display* display : display_manager_->displays()) {
-    display->SchedulePaint(display->root_window(),
-                           gfx::Rect(display->root_window()->bounds().size()));
-  }
 }
 
 void WindowServer::OnUserIdAdded(const UserId& id) {
   activity_monitor_map_[id] = base::MakeUnique<UserActivityMonitor>(nullptr);
 }
 
 void WindowServer::OnUserIdRemoved(const UserId& id) {
   activity_monitor_map_.erase(id);
 }
 
 }  // namespace ws
 }  // namespace ui