Fixes problems with drawn state

components/mus/public/cpp/lib/window_tree_client_impl.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 "components/mus/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 Window* AddWindowToConnection(WindowTreeClientImpl* client,
                               Window* parent,
                               const mojom::WindowDataPtr& window_data) {
   // We don't use the ctor that takes a WindowTreeConnection here, since it
   // will call back to the service and attempt to create a new window.
   Window* window = WindowPrivate::LocalCreate();
   WindowPrivate private_window(window);
   private_window.set_connection(client);
   private_window.set_id(window_data->window_id);
   private_window.set_visible(window_data->visible);
-  private_window.set_drawn(window_data->drawn);
   private_window.LocalSetViewportMetrics(mojom::ViewportMetrics(),
                                          *window_data->viewport_metrics);
   private_window.set_properties(
       window_data->properties
           .To<std::map<std::string, std::vector<uint8_t>>>());
   client->AddWindow(window);
   private_window.LocalSetBounds(gfx::Rect(),
                                 window_data->bounds.To<gfx::Rect>());
   if (parent)
     WindowPrivate(parent).LocalAddChild(window);
@@ skipping 420 matching lines @@
     roots_.insert(window);
     tree_->NewTopLevelWindow(change_id, window->id(),
                              std::move(transport_properties));
   }
   return window;
 }
 
 void WindowTreeClientImpl::OnEmbedImpl(mojom::WindowTree* window_tree,
                                        ConnectionSpecificId connection_id,
                                        mojom::WindowDataPtr root_data,
-                                       Id focused_window_id) {
+                                       Id focused_window_id,
+                                       bool drawn) {
   // WARNING: this is only called if WindowTreeClientImpl was created as the
   // result of an embedding.
   tree_ = window_tree;
   connection_id_ = connection_id;
 
   DCHECK(roots_.empty());
   Window* root = AddWindowToConnection(this, nullptr, root_data);
   roots_.insert(root);
 
   focused_window_ = GetWindowById(focused_window_id);
 
+  WindowPrivate(root).LocalSetParentDrawn(drawn);
+
   delegate_->OnEmbed(root);
 
   if (focused_window_) {
     FOR_EACH_OBSERVER(WindowTreeConnectionObserver, observers_,
                       OnWindowTreeFocusChanged(focused_window_, nullptr));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeClientImpl, WindowTreeConnection implementation:
@@ skipping 15 matching lines @@
   return focused_window_;
 }
 
 Window* WindowTreeClientImpl::NewWindow(
     const Window::SharedProperties* properties) {
   return NewWindowImpl(NewWindowType::CHILD, properties);
 }
 
 Window* WindowTreeClientImpl::NewTopLevelWindow(
     const Window::SharedProperties* properties) {
-  return NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
+  Window* window = NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
+  // Assume newly created top level windows are drawn by default, otherwise
+  // requests to focus will fail. We will get the real value in
+  // OnTopLevelCreated().
+  window->LocalSetParentDrawn(true);
+  return window;
 }
 
 ConnectionSpecificId WindowTreeClientImpl::GetConnectionId() {
   return connection_id_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeClientImpl, WindowTreeClient implementation:
 
 void WindowTreeClientImpl::AddObserver(WindowTreeConnectionObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowTreeClientImpl::RemoveObserver(
     WindowTreeConnectionObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowTreeClientImpl::OnEmbed(ConnectionSpecificId connection_id,
                                    mojom::WindowDataPtr root_data,
                                    mojom::WindowTreePtr tree,
-                                   Id focused_window_id) {
+                                   Id focused_window_id,
+                                   bool drawn) {
   DCHECK(!tree_ptr_);
   tree_ptr_ = std::move(tree);
   tree_ptr_.set_connection_error_handler([this]() { delete this; });
 
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(GetProxy(&window_manager_internal_client_,
                                                tree_ptr_.associated_group()));
   }
 
   OnEmbedImpl(tree_ptr_.get(), connection_id, std::move(root_data),
-              focused_window_id);
+              focused_window_id, drawn);
 }
 
 void WindowTreeClientImpl::OnEmbeddedAppDisconnected(Id window_id) {
   Window* window = GetWindowById(window_id);
   if (window) {
     FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window).observers(),
                       OnWindowEmbeddedAppDisconnected(window));
   }
 }
 
@@ skipping 12 matching lines @@
     return;
 
   InFlightCaptureChange reset_change(this, nullptr);
   if (ApplyServerChangeToExistingInFlightChange(reset_change))
     return;
 
   LocalSetCapture(nullptr);
 }
 
 void WindowTreeClientImpl::OnTopLevelCreated(uint32_t change_id,
-                                             mojom::WindowDataPtr data) {
+                                             mojom::WindowDataPtr data,
+                                             bool drawn) {
   // The server ack'd the top level window we created and supplied the state
   // of the window at the time the server created it. For properties we do not
   // have changes in flight for we can update them immediately. For properties
   // with changes in flight we set the revert value from the server.
 
   if (!in_flight_map_.count(change_id)) {
     // The window may have been destroyed locally before the server could finish
     // creating the window, and before the server received the notification that
     // the window has been destroyed.
     return;
   }
   scoped_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
 
   Window* window = change->window();
   WindowPrivate window_private(window);
 
   // Drawn state and ViewportMetrics always come from the server (they can't
   // be modified locally).
-  window_private.set_drawn(data->drawn);
+  window_private.LocalSetParentDrawn(drawn);
   window_private.LocalSetViewportMetrics(mojom::ViewportMetrics(),
                                          *data->viewport_metrics);
 
   // The default visibilty is false, we only need update visibility if it
   // differs from that.
   if (data->visible) {
     InFlightVisibleChange visible_change(window, data->visible);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
@@ skipping 155 matching lines @@
   if (!window)
     return;
 
   InFlightVisibleChange new_change(window, visible);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetVisible(visible);
 }
 
-void WindowTreeClientImpl::OnWindowDrawnStateChanged(Id window_id, bool drawn) {
+void WindowTreeClientImpl::OnWindowParentDrawnStateChanged(Id window_id,
+                                                           bool drawn) {
   Window* window = GetWindowById(window_id);
   if (window)
-    WindowPrivate(window).LocalSetDrawn(drawn);
+    WindowPrivate(window).LocalSetParentDrawn(drawn);
 }
 
 void WindowTreeClientImpl::OnWindowSharedPropertyChanged(
     Id window_id,
     const mojo::String& name,
     mojo::Array<uint8_t> new_data) {
   Window* window = GetWindowById(window_id);
   if (!window)
     return;
 
@@ skipping 173 matching lines @@
 
 void WindowTreeClientImpl::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
       window->id(), offset.x(), offset.y(), mojo::Insets::From(hit_area));
 }
 
 }  // namespace mus