Cancel drag if display configuration changes.

ash/display/multi_display_manager.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/multi_display_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 41 matching lines @@
 
 MultiDisplayManager::MultiDisplayManager() :
     internal_display_id_(gfx::Display::kInvalidDisplayID) {
   Init();
 }
 
 MultiDisplayManager::~MultiDisplayManager() {
 }
 
 // static
-void MultiDisplayManager::AddRemoveDisplay() {
-  MultiDisplayManager* manager = static_cast<MultiDisplayManager*>(
-      aura::Env::GetInstance()->display_manager());
-  manager->AddRemoveDisplayImpl();
-}
-
 void MultiDisplayManager::CycleDisplay() {
   MultiDisplayManager* manager = static_cast<MultiDisplayManager*>(
       aura::Env::GetInstance()->display_manager());
   manager->CycleDisplayImpl();
 }
 
+// static
 void MultiDisplayManager::ToggleDisplayScale() {
   MultiDisplayManager* manager = static_cast<MultiDisplayManager*>(
       aura::Env::GetInstance()->display_manager());
   manager->ScaleDisplayImpl();
 }
 
 void MultiDisplayManager::InitInternalDisplayInfo() {
 #if defined(OS_CHROMEOS)
   if (!base::chromeos::IsRunningOnChromeOS())
     return;
@@ skipping 191 matching lines @@
   }
 #endif
 
   return base::StringPrintf("Display %d", static_cast<int>(index + 1));
 }
 
 void MultiDisplayManager::OnRootWindowResized(const aura::RootWindow* root,
                                               const gfx::Size& old_size) {
   if (!use_fullscreen_host_window()) {
     gfx::Display& display = FindDisplayForRootWindow(root);
-    display.SetSize(root->GetHostSize());
-    NotifyBoundsChanged(display);
+    if (display.size() != root->GetHostSize()) {
+      display.SetSize(root->GetHostSize());
+      NotifyBoundsChanged(display);
+    }
   }
 }
 
 void MultiDisplayManager::Init() {
   // TODO(oshima): Move this logic to DisplayChangeObserver.
   const string size_str = CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kAuraHostWindowSize);
   vector<string> parts;
   base::SplitString(size_str, ',', &parts);
   for (vector<string>::const_iterator iter = parts.begin();
        iter != parts.end(); ++iter) {
     AddDisplayFromSpec(*iter);
   }
   if (displays_.empty())
     AddDisplayFromSpec(std::string() /* default */);
 }
 
-void MultiDisplayManager::AddRemoveDisplayImpl() {
+void MultiDisplayManager::CycleDisplayImpl() {
   std::vector<gfx::Display> new_displays;
   if (displays_.size() > 1) {
     // Remove if there is more than one display.
     int count = displays_.size() - 1;
     for (Displays::const_iterator iter = displays_.begin(); count-- > 0; ++iter)
       new_displays.push_back(*iter);
   } else {
     // Add if there is only one display.
     new_displays.push_back(displays_[0]);
-    new_displays.push_back(CreateDisplayFromSpec("50+50-1280x768"));
+    new_displays.push_back(CreateDisplayFromSpec("100+200-500x400"));
   }
   if (new_displays.size())
     OnNativeDisplaysChanged(new_displays);
 }
 
-void MultiDisplayManager::CycleDisplayImpl() {
-  if (displays_.size() > 1) {
-    std::vector<gfx::Display> new_displays;
-    for (Displays::const_iterator iter = displays_.begin() + 1;
-         iter != displays_.end(); ++iter) {
-      gfx::Display display = *iter;
-      new_displays.push_back(display);
-    }
-    new_displays.push_back(displays_.front());
-    OnNativeDisplaysChanged(new_displays);
-  }
-}
-
 void MultiDisplayManager::ScaleDisplayImpl() {
   if (displays_.size() > 0) {
     std::vector<gfx::Display> new_displays;
     for (Displays::const_iterator iter = displays_.begin();
          iter != displays_.end(); ++iter) {
       gfx::Display display = *iter;
       float factor = display.device_scale_factor() == 1.0f ? 2.0f : 1.0f;
       display.SetScaleAndBounds(
           factor, gfx::Rect(display.bounds_in_pixel().origin(),
                             display.size().Scale(factor)));
       new_displays.push_back(display);
     }
     OnNativeDisplaysChanged(new_displays);
   }
 }
 
 gfx::Display& MultiDisplayManager::FindDisplayForRootWindow(
     const aura::RootWindow* root_window) {
   int64 id = root_window->GetProperty(kDisplayIdKey);
+  // if id is |kInvaildDisplayID|, it's being deleted.
+  DCHECK(id != gfx::Display::kInvalidDisplayID);
   for (Displays::iterator iter = displays_.begin();
        iter != displays_.end(); ++iter) {
     if ((*iter).id() == id)
       return *iter;
   }
   DLOG(FATAL) << "Could not find display by id:" << id;
   return GetInvalidDisplay();
 }
 
 void MultiDisplayManager::AddDisplayFromSpec(const std::string& spec) {
   gfx::Display display = CreateDisplayFromSpec(spec);
 
   const gfx::Insets insets = display.GetWorkAreaInsets();
   const gfx::Rect& native_bounds = display.bounds_in_pixel();
   display.SetScaleAndBounds(display.device_scale_factor(), native_bounds);
   display.UpdateWorkAreaFromInsets(insets);
   displays_.push_back(display);
 }
 
 void MultiDisplayManager::SetInternalDisplayIdForTest(int64 id) {
   internal_display_id_ = id;
   internal_display_.reset(new gfx::Display(internal_display_id_,
                                            gfx::Rect(800, 600)));
 }
 
 }  // namespace internal
 }  // namespace ash