Fixes problems with drawn state

components/mus/public/interfaces/window_tree.mojom

 // 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.
 
 module mus.mojom;
 
 import "components/mus/public/interfaces/compositor_frame.mojom";
 import "components/mus/public/interfaces/cursor.mojom";
 import "components/mus/public/interfaces/input_events.mojom";
 import "components/mus/public/interfaces/mus_constants.mojom";
 import "components/mus/public/interfaces/surface_id.mojom";
 import "components/mus/public/interfaces/window_manager.mojom";
 import "components/mus/public/interfaces/window_manager_constants.mojom";
 import "ui/mojo/geometry/geometry.mojom";
 import "ui/mojo/ime/text_input_state.mojom";
 
 struct ViewportMetrics {
   mojo.Size size_in_pixels;
   // A value of 0 indicates the real value is not yet available.
   float device_pixel_ratio = 0.0;
 };
 
 struct WindowData {
   uint32 parent_id;
   uint32 window_id;
   mojo.Rect bounds;
   map<string, array<uint8>> properties;
   // True if this window is visible. The window may not be drawn on screen (see
-  // drawn for specifics).
+  // OnWindowParentDrawnStateChanged() for details).
   bool visible;
-  // True if this window is drawn on screen. A window is drawn if attached to
-  // the root and all ancestors (including this window) are visible.
-  bool drawn;
   ViewportMetrics viewport_metrics;
 };
 
 enum ErrorCode {
   NONE,
   VALUE_IN_USE,
   ILLEGAL_ARGUMENT,
 };
 
 // Each Window has support for two surfaces. Generally the |DEFAULT| surface
@@ skipping 204 matching lines @@
 };
 
 // Changes to windows are not sent to the connection that originated the
 // change. For example, if connection 1 changes the bounds of a window by
 // calling SetWindowBounds(), connection 1 does not receive
 // OnWindowBoundsChanged().
 interface WindowTreeClient {
   // Invoked when the client application has been embedded at |root|.
   // See Embed() on WindowTree for more details. |tree| will be a handle back to
   // the window manager service, unless the connection is to the root connection
-  // in which case it will be null.
+  // in which case it will be null. |parent_drawn| is true if roots parent is
+  // drawn, see OnParentDrawnStateChanged() for details.
   OnEmbed(uint16 connection_id,
           WindowData root,
           WindowTree? tree,
-          uint32 focused_window);
+          uint32 focused_window,
+          bool parent_drawn);
 
   // Invoked when the application embedded at |window| is disconnected. In other
   // words the embedded app closes the connection to the server. This is called
   // on the connection that created |window| as well as any ancestors that have
   // the embed root policy.
   OnEmbeddedAppDisconnected(uint32 window);
 
   // Sent when another connection is embedded in the Window this connection was
   // previously embedded in. See Embed() for more information.
   OnUnembed(uint32 window);
 
   // Sent when a window loses capture.
   OnLostCapture(uint32 window);
 
   // Called in response to NewTopLevelWindow() successfully completing.
-  OnTopLevelCreated(uint32 change_id, WindowData data);
+  // |parent_drawn| is true if the parent of the window is drawn, see
+  // OnDrawnStateChanged() for details.
+  OnTopLevelCreated(uint32 change_id, WindowData data, bool parent_drawn);
 
   // Invoked when a window's bounds have changed.
   OnWindowBoundsChanged(uint32 window,
                         mojo.Rect old_bounds,
                         mojo.Rect new_bounds);
 
   OnClientAreaChanged(uint32 window_id,
                       mojo.Insets new_client_area,
                       array<mojo.Rect> new_additional_client_areas);
 
@@ skipping 28 matching lines @@
   OnWindowReordered(uint32 window_id,
                     uint32 relative_window_id,
                     OrderDirection direction);
 
   // Invoked when a window is deleted.
   OnWindowDeleted(uint32 window);
 
   // Invoked when the visibility of the specified window changes.
   OnWindowVisibilityChanged(uint32 window, bool visible);
 
-  // Invoked when a change to the visibility of |window| or one if it's
-  // ancestors is done such that the drawn state changes. This is only invoked
-  // for the top most window of a particular connection. For example, if you
-  // have the hierarchy: A -> B1 -> B2 (B2 is a child of B1 and B1 a child of
-  // A), B1/B2 are from connection 2 and A from connection 1 with all windows
-  // visible and drawn and the visiblity of A changes to false, then connection
-  // 2 is told the drawn state of B1 has changed (to false), but is not told
-  // anything about B2 as it's drawn state can be calculated from that of B1.
+  // Invoked when the drawn state of |window|'s parent changes. The drawn state
+  // is determined by the visibility of a Window and the Windows ancestors. A
+  // Window is drawn if all ancestors are visible, not drawn if any ancestor is
+  // hidden.
   //
-  // NOTE: This is not invoked if OnWindowVisibilityChanged() is invoked.
-  OnWindowDrawnStateChanged(uint32 window, bool drawn);
+  // The initial drawn state is communicated by way of OnTopLevelCreated() or
+  // OnEmbed().
+  //
+  // This function is only called for root Windows as the drawn state of all
+  // other windows can be determined from their parent.
+  OnWindowParentDrawnStateChanged(uint32 window, bool drawn);
 
   // Invoked when a window property is changed. If this change is a removal,
   // |new_data| is null.
   OnWindowSharedPropertyChanged(uint32 window,
                                 string name,
                                 array<uint8>? new_data);
 
   // Invoked when an event is targeted at the specified window. The client must
   // call WindowTree::OnWindowInputEventAck() with the same |event_id| to notify
   // that the event has been processed, and with a boolean |handled| to notify
@@ skipping 21 matching lines @@
   // See description of WindowManager for details.
   GetWindowManager(associated WindowManager& internal);
 };
 
 // Mus provides this interface as a way for clients to connect and obtain a
 // WindowTree handle with a supplied WindowTreeClient handle. The
 // WindowTreeClient has no roots, use NewTopLevelWindow() to create one.
 interface WindowTreeFactory {
   CreateWindowTree(WindowTree& tree_request, WindowTreeClient client);
 };