Notify primary display reassignment

ash/display/display_controller_unittest.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 "ash/ash_switches.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
@@ skipping 51 matching lines @@
                      public gfx::DisplayObserver,
                      public aura::client::FocusChangeObserver,
                      public aura::client::ActivationChangeObserver {
  public:
   TestObserver()
       : changing_count_(0),
         changed_count_(0),
         bounds_changed_count_(0),
         rotation_changed_count_(0),
         workarea_changed_count_(0),
+        primary_changed_count_(0),
         changed_display_id_(0),
         focus_changed_count_(0),
         activation_changed_count_(0) {
     Shell::GetInstance()->display_controller()->AddObserver(this);
     Shell::GetScreen()->AddObserver(this);
     aura::client::GetFocusClient(Shell::GetPrimaryRootWindow())->
         AddObserver(this);
     aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
         AddObserver(this);
   }
@@ skipping 14 matching lines @@
   // Overrideen from gfx::DisplayObserver
   void OnDisplayMetricsChanged(const gfx::Display& display,
                                uint32_t metrics) override {
     changed_display_id_ = display.id();
     if (metrics & DISPLAY_METRIC_BOUNDS)
       ++bounds_changed_count_;
     if (metrics & DISPLAY_METRIC_ROTATION)
       ++rotation_changed_count_;
     if (metrics & DISPLAY_METRIC_WORK_AREA)
       ++workarea_changed_count_;
+    if (metrics & DISPLAY_METRIC_PRIMARY)
+      ++primary_changed_count_;
   }
   void OnDisplayAdded(const gfx::Display& new_display) override {}
   void OnDisplayRemoved(const gfx::Display& old_display) override {}
 
   // Overridden from aura::client::FocusChangeObserver
   void OnWindowFocused(aura::Window* gained_focus,
                        aura::Window* lost_focus) override {
     focus_changed_count_++;
   }
 
@@ skipping 16 matching lines @@
   }
 
   int64 GetRotationChangedCountAndReset() {
     return Resetter<int>(&rotation_changed_count_).value();
   }
 
   int64 GetWorkareaChangedCountAndReset() {
     return Resetter<int>(&workarea_changed_count_).value();
   }
 
+  int64 GetPrimaryChangedCountAndReset() {
+    return Resetter<int>(&primary_changed_count_).value();
+  }
+
   int64 GetChangedDisplayIdAndReset() {
     return Resetter<int64>(&changed_display_id_).value();
   }
 
   int GetFocusChangedCountAndReset() {
     return Resetter<int>(&focus_changed_count_).value();
   }
 
   int GetActivationChangedCountAndReset() {
     return Resetter<int>(&activation_changed_count_).value();
   }
 
  private:
   int changing_count_;
   int changed_count_;
 
   int bounds_changed_count_;
   int rotation_changed_count_;
   int workarea_changed_count_;
+  int primary_changed_count_;
   int64 changed_display_id_;
 
   int focus_changed_count_;
   int activation_changed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 gfx::Display GetPrimaryDisplay() {
   return Shell::GetScreen()->GetDisplayNearestWindow(
@@ skipping 403 matching lines @@
   window_state->OnWMEvent(&toggle_fullscreen_event);
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_EQ("0,0 250x250", w1->bounds().ToString());
   // Dock mode.
   TestObserver observer;
   display_info_list.clear();
   display_info_list.push_back(external_display_info);
   display_manager->OnNativeDisplaysChanged(display_info_list);
   EXPECT_EQ(1U, display_manager->GetNumDisplays());
   EXPECT_EQ(1U, display_manager->num_connected_displays());
-  EXPECT_EQ(0, observer.GetChangedDisplayIdAndReset());
-  EXPECT_EQ(0, observer.GetBoundsChangedCountAndReset());
-  EXPECT_EQ(0, observer.GetWorkareaChangedCountAndReset());
+  // Observers are called due to primary change.
+  EXPECT_EQ(2, observer.GetChangedDisplayIdAndReset());
+  EXPECT_EQ(1, observer.GetBoundsChangedCountAndReset());
+  EXPECT_EQ(1, observer.GetWorkareaChangedCountAndReset());
+  EXPECT_EQ(1, observer.GetPrimaryChangedCountAndReset());
   EXPECT_EQ(1, observer.CountAndReset());
   EXPECT_EQ(0, observer.GetFocusChangedCountAndReset());
   EXPECT_EQ(0, observer.GetActivationChangedCountAndReset());
 
   EXPECT_TRUE(window_state->IsFullscreen());
   EXPECT_EQ("0,0 500x500", w1->bounds().ToString());
 }
 
 TEST_F(DisplayControllerTest, BoundsUpdated) {
   if (!SupportsMultipleDisplays())
@@ skipping 730 matching lines @@
   EXPECT_EQ("aura_root_x", GetXWindowName(secondary->GetHost()));
 
   // Switching back to single display.
   UpdateDisplay("300x400");
   EXPECT_EQ("aura_root_0", GetXWindowName(
       Shell::GetPrimaryRootWindow()->GetHost()));
 }
 #endif
 
 }  // namespace ash