Fixes problems with drawn state

components/mus/ws/window_tree.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/ws/window_tree.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 76 matching lines @@
 void WindowTree::Init(scoped_ptr<WindowTreeBinding> binding,
                       mojom::WindowTreePtr tree) {
   DCHECK(!binding_);
   binding_ = std::move(binding);
 
   if (roots_.empty())
     return;
 
   std::vector<const ServerWindow*> to_send;
   CHECK_EQ(1u, roots_.size());
-  GetUnknownWindowsFrom(*roots_.begin(), &to_send);
+  const ServerWindow* root = *roots_.begin();
+  GetUnknownWindowsFrom(root, &to_send);
 
-  Display* display = GetDisplay(*roots_.begin());
+  Display* display = GetDisplay(root);
   const ServerWindow* focused_window =
       display ? display->GetFocusedWindow() : nullptr;
   if (focused_window)
     focused_window = access_policy_->GetWindowForFocusChange(focused_window);
   ClientWindowId focused_window_id;
   if (focused_window)
     IsWindowKnown(focused_window, &focused_window_id);
 
+  const bool drawn = root->parent() && root->parent()->IsDrawn();
   client()->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
-                    focused_window_id.id);
+                    focused_window_id.id, drawn);
 }
 
 void WindowTree::ConfigureWindowManager() {
   DCHECK(!window_manager_internal_);
   window_manager_internal_ = binding_->GetWindowManager();
 }
 
 const ServerWindow* WindowTree::GetWindow(const WindowId& id) const {
   if (id_ == id.connection_id) {
     auto iter = created_window_map_.find(id);
@@ skipping 212 matching lines @@
       std::move(waiting_for_top_level_window_info_));
   binding_->SetIncomingMethodCallProcessingPaused(false);
   // We were paused, so the id should still be valid.
   DCHECK(IsValidIdForNewWindow(
       waiting_for_top_level_window_info->client_window_id));
   client_id_to_window_id_map_[waiting_for_top_level_window_info
                                   ->client_window_id] = window->id();
   window_id_to_client_id_map_[window->id()] =
       waiting_for_top_level_window_info->client_window_id;
   roots_.insert(window);
-  client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window));
+  const bool drawn = window->parent() && window->parent()->IsDrawn();
+  client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window),
+                              drawn);
 }
 
 void WindowTree::OnChangeCompleted(uint32_t change_id, bool success) {
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::OnAccelerator(uint32_t accelerator_id,
                                const ui::Event& event) {
   DCHECK(window_manager_internal_);
   window_manager_internal_->OnAccelerator(accelerator_id,
@@ skipping 455 matching lines @@
     parent = nullptr;
   mojom::WindowDataPtr window_data(mojom::WindowData::New());
   window_data->parent_id =
       parent ? ClientWindowIdForWindow(parent).id : ClientWindowId().id;
   window_data->window_id =
       window ? ClientWindowIdForWindow(window).id : ClientWindowId().id;
   window_data->bounds = Rect::From(window->bounds());
   window_data->properties =
       mojo::Map<String, Array<uint8_t>>::From(window->properties());
   window_data->visible = window->visible();
-  window_data->drawn = window->IsDrawn();
   window_data->viewport_metrics =
       window_server_->GetViewportMetricsForWindow(window);
   return window_data;
 }
 
 void WindowTree::GetWindowTreeImpl(
     const ServerWindow* window,
     std::vector<const ServerWindow*>* windows) const {
   DCHECK(window);
 
@@ skipping 12 matching lines @@
 
 void WindowTree::NotifyDrawnStateChanged(const ServerWindow* window,
                                          bool new_drawn_value) {
   // Even though we don't know about window, it may be an ancestor of our root,
   // in which case the change may effect our roots drawn state.
   if (roots_.empty())
     return;
 
   for (auto* root : roots_) {
     if (window->Contains(root) && (new_drawn_value != root->IsDrawn())) {
-      client()->OnWindowDrawnStateChanged(ClientWindowIdForWindow(root).id,
-                                          new_drawn_value);
+      client()->OnWindowParentDrawnStateChanged(
+          ClientWindowIdForWindow(root).id, new_drawn_value);
     }
   }
 }
 
 void WindowTree::DestroyWindows() {
   if (created_window_map_.empty())
     return;
 
   Operation op(this, window_server_, OperationType::DELETE_WINDOW);
   // If we get here from the destructor we're not going to get
@@ skipping 505 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus