chromeos: makes it possible for windows to outlive WindowTreeClient

ui/aura/mus/window_tree_client.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 33 matching lines @@
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_client_test_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/mus/window_tree_host_mus_init_params.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
+#include "ui/aura/window_port_for_shutdown.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(HiWord)
@@ skipping 190 matching lines @@
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
 
   if (discardable_shared_memory_manager_)
     base::DiscardableMemoryAllocator::SetInstance(nullptr);
 
   for (WindowTreeClientObserver& observer : observers_)
     observer.OnWillDestroyClient(this);
 
-  // Clients should properly delete all of their windows before shutdown.
-  CHECK(windows_.empty());
-
   capture_synchronizer_.reset();
 
   client::GetTransientWindowClient()->RemoveObserver(this);
 
   Env* env = Env::GetInstance();
   if (compositor_context_factory_ &&
       env->context_factory() == compositor_context_factory_.get()) {
     env->set_context_factory(initial_context_factory_);
   }
+
+  // Allow for windows to exist (and be created) after we are destroyed. This
+  // is necessary because of shutdown ordering (WindowTreeClient is destroyed
+  // before windows).
+  in_shutdown_ = true;
+  IdToWindowMap windows;
+  std::swap(windows, windows_);
+  for (auto& pair : windows)
+    WindowPortForShutdown::Install(pair.second->GetWindow());
+
+  env->WindowTreeClientDestroyed(this);
+  CHECK(windows_.empty());
 }
 
 void WindowTreeClient::ConnectViaWindowTreeFactory() {
   // The client id doesn't really matter, we use 101 purely for debugging.
   client_id_ = 101;
 
   ui::mojom::WindowTreeFactoryPtr factory;
   connector_->BindInterface(ui::mojom::kServiceName, &factory);
   ui::mojom::WindowTreePtr window_tree;
   factory->CreateWindowTree(MakeRequest(&window_tree),
@@ skipping 451 matching lines @@
           base::Bind(&WindowTreeClient::OnSetDisplayRootDone,
                      base::Unretained(this)));
     }
   }
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window, Origin origin) {
   if (focus_synchronizer_->focused_window() == window)
     focus_synchronizer_->OnFocusedWindowDestroyed();
 
+  // If we're |in_shutdown_| there is no point in telling the server about the
+  // deletion. The connection to the server is about to be dropped and the
+  // server will take appropriate action.
   // TODO: decide how to deal with windows not owned by this client.
-  if (origin == Origin::CLIENT &&
+  if (!in_shutdown_ && origin == Origin::CLIENT &&
       (WasCreatedByThisClient(window) || IsRoot(window))) {
     const uint32_t change_id =
         ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
             window, ChangeType::DELETE_WINDOW));
     tree_->DeleteWindow(change_id, window->server_id());
   }
 
   windows_.erase(window->server_id());
 
   for (auto& entry : embedded_windows_) {
@@ skipping 1320 matching lines @@
 }
 
 void WindowTreeClient::OnCompositingLockStateChanged(
     ui::Compositor* compositor) {}
 
 void WindowTreeClient::OnCompositingShuttingDown(ui::Compositor* compositor) {
   compositor->RemoveObserver(this);
 }
 
 }  // namespace aura