Cancel drag if display configuration changes.

ash/display/display_controller.cc

 // Copyright (c) 2012 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/display_controller.h"
 
 #include <algorithm>
 
 #include "ash/ash_switches.h"
 #include "ash/display/multi_display_manager.h"
@@ skipping 162 matching lines @@
       else if (layout == 'r')
         default_display_layout_.position = DisplayLayout::RIGHT;
       else if (layout == 'l')
         default_display_layout_.position = DisplayLayout::LEFT;
       default_display_layout_.offset = offset;
     }
   }
   UpdateDisplayBoundsForLayout();
 }
 
+void DisplayController::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void DisplayController::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 aura::RootWindow* DisplayController::GetPrimaryRootWindow() {
   DCHECK(!root_windows_.empty());
   aura::DisplayManager* display_manager =
       aura::Env::GetInstance()->display_manager();
   return root_windows_[display_manager->GetDisplayAt(0)->id()];
 }
 
 aura::RootWindow* DisplayController::GetRootWindowForDisplayId(int64 id) {
   return root_windows_[id];
 }
@@ skipping 33 matching lines @@
            root_windows_.begin(); it != root_windows_.end(); ++it) {
     internal::RootWindowController* controller =
         GetRootWindowController(it->second);
     if (controller)
       controllers.push_back(controller);
   }
   return controllers;
 }
 
 void DisplayController::SetDefaultDisplayLayout(const DisplayLayout& layout) {
-  default_display_layout_ = layout;
-  UpdateDisplayBoundsForLayout();
+  if (default_display_layout_.position != layout.position ||
+      default_display_layout_.offset != layout.offset) {
+    default_display_layout_ = layout;
+    NotifyDisplayConfigurationChanging();
+    UpdateDisplayBoundsForLayout();
+  }
 }
 
 void DisplayController::SetLayoutForDisplayName(const std::string& name,
                                                 const DisplayLayout& layout) {
-  secondary_layouts_[name] = layout;
-  UpdateDisplayBoundsForLayout();
+  DisplayLayout& display_for_name = secondary_layouts_[name];
+  if (display_for_name.position != layout.position ||
+      display_for_name.offset != layout.offset) {
+    secondary_layouts_[name] = layout;
+    NotifyDisplayConfigurationChanging();
+    UpdateDisplayBoundsForLayout();
+  }
 }
 
 const DisplayLayout& DisplayController::GetLayoutForDisplayName(
     const std::string& name) {
   std::map<std::string, DisplayLayout>::const_iterator it =
       secondary_layouts_.find(name);
 
   if (it != secondary_layouts_.end())
     return it->second;
   return default_display_layout_;
 }
 
 void DisplayController::OnDisplayBoundsChanged(const gfx::Display& display) {
+  NotifyDisplayConfigurationChanging();
   root_windows_[display.id()]->SetHostBounds(display.bounds_in_pixel());
   UpdateDisplayBoundsForLayout();
 }
 
 void DisplayController::OnDisplayAdded(const gfx::Display& display) {
   DCHECK(!root_windows_.empty());
+  NotifyDisplayConfigurationChanging();
   aura::RootWindow* root = AddRootWindowForDisplay(display);
   Shell::GetInstance()->InitRootWindowForSecondaryDisplay(root);
   UpdateDisplayBoundsForLayout();
 }
 
 void DisplayController::OnDisplayRemoved(const gfx::Display& display) {
   aura::RootWindow* root = root_windows_[display.id()];
   DCHECK(root);
   // Primary display should never be removed by DisplayManager.
   DCHECK(root != GetPrimaryRootWindow());
+  NotifyDisplayConfigurationChanging();
   // Display for root window will be deleted when the Primary RootWindow
   // is deleted by the Shell.
   if (root != GetPrimaryRootWindow()) {
     root_windows_.erase(display.id());
     internal::RootWindowController* controller =
         GetRootWindowController(root);
-    if (controller) {
-      controller->MoveWindowsTo(GetPrimaryRootWindow());
-      delete controller;
-    } else {
-      delete root;
-    }
+    DCHECK(controller);
+    controller->MoveWindowsTo(GetPrimaryRootWindow());
+    // Delete most of root window related objects, but don't delete
+    // root window itself yet because the stak may be using it.
+    controller->Shutdown();
+    MessageLoop::current()->DeleteSoon(FROM_HERE, controller);
   }
 }
 
 aura::RootWindow* DisplayController::AddRootWindowForDisplay(
     const gfx::Display& display) {
   static bool force_constrain_pointer_to_root =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshConstrainPointerToRoot);
 
   aura::RootWindow* root = aura::Env::GetInstance()->display_manager()->
@@ skipping 55 matching lines @@
     case DisplayLayout::LEFT:
       new_secondary_origin.Offset(-secondary_bounds.width(), offset);
       break;
   }
   gfx::Insets insets = secondary_display->GetWorkAreaInsets();
   secondary_display->set_bounds(
       gfx::Rect(new_secondary_origin, secondary_bounds.size()));
   secondary_display->UpdateWorkAreaFromInsets(insets);
 }
 
+void DisplayController::NotifyDisplayConfigurationChanging() {
+  FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
+}
+
 }  // namespace ash