Close mirroring window only when necessary

ash/display/mirror_window_controller.cc

 // Copyright (c) 2013 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 "ash/display/mirror_window_controller.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 118 matching lines @@
   gfx::Size mirror_window_host_size;
   aura::Window* mirror_window = nullptr;
 };
 
 MirrorWindowController::MirroringHostInfo::MirroringHostInfo() {
 }
 MirrorWindowController::MirroringHostInfo::~MirroringHostInfo() {
 }
 
 MirrorWindowController::MirrorWindowController()
-    : screen_position_client_(new MirroringScreenPositionClient(this)) {
+    : multi_display_mode_(DisplayManager::EXTENDED),
+      screen_position_client_(new MirroringScreenPositionClient(this)) {
 }
 
 MirrorWindowController::~MirrorWindowController() {
   // Make sure the root window gets deleted before cursor_window_delegate.
-  Close();
+  Close(false);
 }
 
 void MirrorWindowController::UpdateWindow(
     const std::vector<DisplayInfo>& display_info_list) {
   static int mirror_host_count = 0;
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   const gfx::Display& primary = Shell::GetScreen()->GetPrimaryDisplay();
   const DisplayInfo& source_display_info =
       display_manager->GetDisplayInfo(primary.id());
 
@@ skipping 85 matching lines @@
   }
 
   // Deleting WTHs for disconnected displays.
   if (mirroring_host_info_map_.size() > display_info_list.size()) {
     for (MirroringHostInfoMap::iterator iter = mirroring_host_info_map_.begin();
          iter != mirroring_host_info_map_.end();) {
       if (std::find_if(display_info_list.begin(), display_info_list.end(),
                        [iter](const DisplayInfo& info) {
                          return info.id() == iter->first;
                        }) == display_info_list.end()) {
-        CloseAndDeleteHost(iter->second);
+        CloseAndDeleteHost(iter->second, true);
         iter = mirroring_host_info_map_.erase(iter);
       } else {
         ++iter;
       }
     }
   }
 }
 
 void MirrorWindowController::UpdateWindow() {
   if (!mirroring_host_info_map_.size())
     return;
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   std::vector<DisplayInfo> display_info_list;
   for (auto& pair : mirroring_host_info_map_)
     display_info_list.push_back(display_manager->GetDisplayInfo(pair.first));
   UpdateWindow(display_info_list);
 }
 
-void MirrorWindowController::Close() {
-  for (auto& info : mirroring_host_info_map_) {
-    CloseAndDeleteHost(info.second);
-  }
+void MirrorWindowController::CloseIfNotNecessary() {
+  DisplayManager* display_manager = Shell::GetInstance()->display_manager();
+
+  DisplayManager::MultiDisplayMode new_mode =
+      display_manager->IsInUnifiedMode()
+          ? DisplayManager::UNIFIED
+          : (display_manager->IsInMirrorMode() ? DisplayManager::MIRRORING
+                                               : DisplayManager::EXTENDED);
+  if (multi_display_mode_ != new_mode)
+    Close(true);
+  multi_display_mode_ = new_mode;
+}
+
+void MirrorWindowController::Close(bool delay_host_deletion) {
+  for (auto& info : mirroring_host_info_map_)
+    CloseAndDeleteHost(info.second, delay_host_deletion);
+
   mirroring_host_info_map_.clear();
   if (reflector_) {
     aura::Env::GetInstance()->context_factory()->RemoveReflector(
         reflector_.get());
     reflector_.reset();
   }
 }
 
 void MirrorWindowController::OnHostResized(const aura::WindowTreeHost* host) {
   for (auto& pair : mirroring_host_info_map_) {
@@ skipping 52 matching lines @@
   return mirroring_host_info_map_[id]->ash_host.get();
 }
 
 aura::Window::Windows MirrorWindowController::GetAllRootWindows() const {
   aura::Window::Windows root_windows;
   for (const auto& pair : mirroring_host_info_map_)
     root_windows.push_back(pair.second->ash_host->AsWindowTreeHost()->window());
   return root_windows;
 }
 
-void MirrorWindowController::CloseAndDeleteHost(MirroringHostInfo* host_info) {
+void MirrorWindowController::CloseAndDeleteHost(MirroringHostInfo* host_info,
+                                                bool delay_host_deletion) {
   aura::WindowTreeHost* host = host_info->ash_host->AsWindowTreeHost();
 
   aura::client::SetScreenPositionClient(host->window(), nullptr);
 
   NoneCaptureClient* capture_client = static_cast<NoneCaptureClient*>(
       aura::client::GetCaptureClient(host->window()));
   aura::client::SetCaptureClient(host->window(), nullptr);
   delete capture_client;
 
   host->RemoveObserver(Shell::GetInstance()->display_controller());
   host->RemoveObserver(this);
   host_info->ash_host->PrepareForShutdown();
   reflector_->RemoveMirroringLayer(host_info->mirror_window->layer());
 
-  delete host_info;
+  // EventProcessor may be accessed after this call if the mirroring window
+  // was deleted as a result of input event (e.g. shortcut), so don't delete
+  // now.
+  if (delay_host_deletion)
+    base::MessageLoop::current()->DeleteSoon(FROM_HERE, host_info);
+  else
+    delete host_info;
 }
 
 scoped_ptr<RootWindowTransformer>
 MirrorWindowController::CreateRootWindowTransformer() const {
   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
   const DisplayInfo& mirror_display_info =
       display_manager->GetDisplayInfo(display_manager->mirroring_display_id());
   const DisplayInfo& source_display_info = display_manager->GetDisplayInfo(
       Shell::GetScreen()->GetPrimaryDisplay().id());
   DCHECK(display_manager->IsInMirrorMode());
   return scoped_ptr<RootWindowTransformer>(
       CreateRootWindowTransformerForMirroredDisplay(source_display_info,
                                                     mirror_display_info));
 }
 
 }  // namespace ash