display_controller_unittest.cc revision 7dbb3d5cf0c15f500944d211057644d6a2f37371 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ash/display/display_controller.h"
6
7#include "ash/display/display_info.h"
8#include "ash/display/display_layout_store.h"
9#include "ash/display/display_manager.h"
10#include "ash/launcher/launcher.h"
11#include "ash/screen_ash.h"
12#include "ash/shelf/shelf_widget.h"
13#include "ash/shell.h"
14#include "ash/test/ash_test_base.h"
15#include "ash/test/cursor_manager_test_api.h"
16#include "ui/aura/env.h"
17#include "ui/aura/root_window.h"
18#include "ui/aura/test/event_generator.h"
19#include "ui/aura/window_tracker.h"
20#include "ui/base/events/event_handler.h"
21#include "ui/gfx/display.h"
22#include "ui/gfx/screen.h"
23#include "ui/views/widget/widget.h"
24
25#if defined(USE_X11)
26#include "ui/base/x/x11_util.h"
27#include <X11/Xlib.h>
28#undef RootWindow
29#endif
30
31namespace ash {
32namespace test {
33namespace {
34
35const char kDesktopBackgroundView[] = "DesktopBackgroundView";
36
37class TestObserver : public DisplayController::Observer {
38 public:
39  TestObserver() : changing_count_(0), changed_count_(0) {
40    Shell::GetInstance()->display_controller()->AddObserver(this);
41  }
42
43  virtual ~TestObserver() {
44    Shell::GetInstance()->display_controller()->RemoveObserver(this);
45  }
46
47  virtual void OnDisplayConfigurationChanging() OVERRIDE {
48    ++changing_count_;
49  }
50
51  virtual void OnDisplayConfigurationChanged() OVERRIDE {
52    ++changed_count_;
53  }
54
55  int CountAndReset() {
56    EXPECT_EQ(changing_count_, changed_count_);
57    int c = changing_count_;
58    changing_count_ = changed_count_ = 0;
59    return c;
60  }
61
62 private:
63  int changing_count_;
64  int changed_count_;
65
66  DISALLOW_COPY_AND_ASSIGN(TestObserver);
67};
68
69gfx::Display GetPrimaryDisplay() {
70  return Shell::GetScreen()->GetDisplayNearestWindow(
71      Shell::GetAllRootWindows()[0]);
72}
73
74gfx::Display GetSecondaryDisplay() {
75  return Shell::GetScreen()->GetDisplayNearestWindow(
76      Shell::GetAllRootWindows()[1]);
77}
78
79void SetSecondaryDisplayLayoutAndOffset(DisplayLayout::Position position,
80                                        int offset) {
81  DisplayLayout layout(position, offset);
82  ASSERT_GT(Shell::GetScreen()->GetNumDisplays(), 1);
83  Shell::GetInstance()->display_controller()->
84      SetLayoutForCurrentDisplays(layout);
85}
86
87void SetSecondaryDisplayLayout(DisplayLayout::Position position) {
88  SetSecondaryDisplayLayoutAndOffset(position, 0);
89}
90
91void SetDefaultDisplayLayout(DisplayLayout::Position position) {
92  Shell::GetInstance()->display_manager()->layout_store()->
93      SetDefaultDisplayLayout(DisplayLayout(position, 0));
94}
95
96class DisplayControllerShutdownTest : public test::AshTestBase {
97 public:
98  virtual void TearDown() OVERRIDE {
99    test::AshTestBase::TearDown();
100    if (!SupportsMultipleDisplays())
101      return;
102
103    // Make sure that primary display is accessible after shutdown.
104    gfx::Display primary = Shell::GetScreen()->GetPrimaryDisplay();
105    EXPECT_EQ("0,0 444x333", primary.bounds().ToString());
106    EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
107  }
108};
109
110class TestEventHandler : public ui::EventHandler {
111 public:
112  TestEventHandler() : target_root_(NULL),
113                       touch_radius_x_(0.0),
114                       touch_radius_y_(0.0),
115                       scroll_x_offset_(0.0),
116                       scroll_y_offset_(0.0),
117                       scroll_x_offset_ordinal_(0.0),
118                       scroll_y_offset_ordinal_(0.0) {}
119  virtual ~TestEventHandler() {}
120
121  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
122    if (event->flags() & ui::EF_IS_SYNTHESIZED &&
123        event->type() != ui::ET_MOUSE_EXITED &&
124        event->type() != ui::ET_MOUSE_ENTERED) {
125      return;
126    }
127    aura::Window* target = static_cast<aura::Window*>(event->target());
128    mouse_location_ = event->root_location();
129    target_root_ = target->GetRootWindow();
130    event->StopPropagation();
131  }
132
133  virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
134    aura::Window* target = static_cast<aura::Window*>(event->target());
135    // Only record when the target is the background which covers
136    // entire root window.
137    if (target->name() != kDesktopBackgroundView)
138      return;
139    touch_radius_x_ = event->radius_x();
140    touch_radius_y_ = event->radius_y();
141    event->StopPropagation();
142  }
143
144  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
145    aura::Window* target = static_cast<aura::Window*>(event->target());
146    // Only record when the target is the background which covers
147    // entire root window.
148    if (target->name() != kDesktopBackgroundView)
149      return;
150
151    if (event->type() == ui::ET_SCROLL) {
152      scroll_x_offset_ = event->x_offset();
153      scroll_y_offset_ = event->y_offset();
154      scroll_x_offset_ordinal_ = event->x_offset_ordinal();
155      scroll_y_offset_ordinal_ = event->y_offset_ordinal();
156    }
157    event->StopPropagation();
158  }
159
160  std::string GetLocationAndReset() {
161    std::string result = mouse_location_.ToString();
162    mouse_location_.SetPoint(0, 0);
163    target_root_ = NULL;
164    return result;
165  }
166
167  float touch_radius_x() { return touch_radius_x_; }
168  float touch_radius_y() { return touch_radius_y_; }
169  float scroll_x_offset() { return scroll_x_offset_; }
170  float scroll_y_offset() { return scroll_y_offset_; }
171  float scroll_x_offset_ordinal() { return scroll_x_offset_ordinal_; }
172  float scroll_y_offset_ordinal() { return scroll_y_offset_ordinal_; }
173
174 private:
175  gfx::Point mouse_location_;
176  aura::RootWindow* target_root_;
177
178  float touch_radius_x_;
179  float touch_radius_y_;
180  float scroll_x_offset_;
181  float scroll_y_offset_;
182  float scroll_x_offset_ordinal_;
183  float scroll_y_offset_ordinal_;
184
185  DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
186};
187
188gfx::Display::Rotation GetStoredRotation(int64 id) {
189  return Shell::GetInstance()->display_manager()->GetDisplayInfo(id).rotation();
190}
191
192float GetStoredUIScale(int64 id) {
193  return Shell::GetInstance()->display_manager()->GetDisplayInfo(id).ui_scale();
194}
195
196#if defined(USE_X11)
197void GetPrimaryAndSeconary(aura::RootWindow** primary,
198                           aura::RootWindow** secondary) {
199  *primary = Shell::GetPrimaryRootWindow();
200  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
201  *secondary = root_windows[0] == *primary ? root_windows[1] : root_windows[0];
202}
203
204std::string GetXWindowName(aura::RootWindow* window) {
205  char* name = NULL;
206  XFetchName(ui::GetXDisplay(), window->GetAcceleratedWidget(), &name);
207  return std::string(name);
208}
209#endif
210
211}  // namespace
212
213typedef test::AshTestBase DisplayControllerTest;
214
215TEST_F(DisplayControllerShutdownTest, Shutdown) {
216  if (!SupportsMultipleDisplays())
217    return;
218
219  UpdateDisplay("444x333, 200x200");
220}
221
222TEST_F(DisplayControllerTest, SecondaryDisplayLayout) {
223  if (!SupportsMultipleDisplays())
224    return;
225
226  TestObserver observer;
227  UpdateDisplay("500x500,400x400");
228  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
229  gfx::Display* secondary_display =
230      Shell::GetInstance()->display_manager()->GetDisplayAt(1);
231  gfx::Insets insets(5, 5, 5, 5);
232  secondary_display->UpdateWorkAreaFromInsets(insets);
233
234  // Default layout is RIGHT.
235  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
236  EXPECT_EQ("500,0 400x400", GetSecondaryDisplay().bounds().ToString());
237  EXPECT_EQ("505,5 390x390", GetSecondaryDisplay().work_area().ToString());
238
239  // Layout the secondary display to the bottom of the primary.
240  SetSecondaryDisplayLayout(DisplayLayout::BOTTOM);
241  EXPECT_EQ(1, observer.CountAndReset());
242  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
243  EXPECT_EQ("0,500 400x400", GetSecondaryDisplay().bounds().ToString());
244  EXPECT_EQ("5,505 390x390", GetSecondaryDisplay().work_area().ToString());
245
246  // Layout the secondary display to the left of the primary.
247  SetSecondaryDisplayLayout(DisplayLayout::LEFT);
248  EXPECT_EQ(1, observer.CountAndReset());
249  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
250  EXPECT_EQ("-400,0 400x400", GetSecondaryDisplay().bounds().ToString());
251  EXPECT_EQ("-395,5 390x390", GetSecondaryDisplay().work_area().ToString());
252
253  // Layout the secondary display to the top of the primary.
254  SetSecondaryDisplayLayout(DisplayLayout::TOP);
255  EXPECT_EQ(1, observer.CountAndReset());
256  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
257  EXPECT_EQ("0,-400 400x400", GetSecondaryDisplay().bounds().ToString());
258  EXPECT_EQ("5,-395 390x390", GetSecondaryDisplay().work_area().ToString());
259
260  // Layout to the right with an offset.
261  SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, 300);
262  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
263  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
264  EXPECT_EQ("500,300 400x400", GetSecondaryDisplay().bounds().ToString());
265
266  // Keep the minimum 100.
267  SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, 490);
268  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
269  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
270  EXPECT_EQ("500,400 400x400", GetSecondaryDisplay().bounds().ToString());
271
272  SetSecondaryDisplayLayoutAndOffset(DisplayLayout::RIGHT, -400);
273  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
274  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
275  EXPECT_EQ("500,-300 400x400", GetSecondaryDisplay().bounds().ToString());
276
277  //  Layout to the bottom with an offset.
278  SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -200);
279  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
280  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
281  EXPECT_EQ("-200,500 400x400", GetSecondaryDisplay().bounds().ToString());
282
283  // Keep the minimum 100.
284  SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, 490);
285  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
286  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
287  EXPECT_EQ("400,500 400x400", GetSecondaryDisplay().bounds().ToString());
288
289  SetSecondaryDisplayLayoutAndOffset(DisplayLayout::BOTTOM, -400);
290  EXPECT_EQ(1, observer.CountAndReset());  // resize and add
291  EXPECT_EQ("0,0 500x500", GetPrimaryDisplay().bounds().ToString());
292  EXPECT_EQ("-300,500 400x400", GetSecondaryDisplay().bounds().ToString());
293}
294
295TEST_F(DisplayControllerTest, BoundsUpdated) {
296  if (!SupportsMultipleDisplays())
297    return;
298
299  TestObserver observer;
300  SetDefaultDisplayLayout(DisplayLayout::BOTTOM);
301  UpdateDisplay("200x200,300x300");  // layout, resize and add.
302  EXPECT_EQ(1, observer.CountAndReset());
303
304  internal::DisplayManager* display_manager =
305      Shell::GetInstance()->display_manager();
306  gfx::Display* secondary_display = display_manager->GetDisplayAt(1);
307  gfx::Insets insets(5, 5, 5, 5);
308  secondary_display->UpdateWorkAreaFromInsets(insets);
309
310  EXPECT_EQ("0,0 200x200", GetPrimaryDisplay().bounds().ToString());
311  EXPECT_EQ("0,200 300x300", GetSecondaryDisplay().bounds().ToString());
312  EXPECT_EQ("5,205 290x290", GetSecondaryDisplay().work_area().ToString());
313
314  UpdateDisplay("400x400,200x200");
315  EXPECT_EQ(1, observer.CountAndReset());  // two resizes
316  EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
317  EXPECT_EQ("0,400 200x200", GetSecondaryDisplay().bounds().ToString());
318
319  UpdateDisplay("400x400,300x300");
320  EXPECT_EQ(1, observer.CountAndReset());
321  EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
322  EXPECT_EQ("0,400 300x300", GetSecondaryDisplay().bounds().ToString());
323
324  UpdateDisplay("400x400");
325  EXPECT_EQ(1, observer.CountAndReset());
326  EXPECT_EQ("0,0 400x400", GetPrimaryDisplay().bounds().ToString());
327  EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
328
329  UpdateDisplay("400x500*2,300x300");
330  EXPECT_EQ(1, observer.CountAndReset());
331  ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
332  EXPECT_EQ("0,0 200x250", GetPrimaryDisplay().bounds().ToString());
333  EXPECT_EQ("0,250 300x300", GetSecondaryDisplay().bounds().ToString());
334
335  // No change
336  UpdateDisplay("400x500*2,300x300");
337  EXPECT_EQ(0, observer.CountAndReset());
338
339  // Rotation
340  int64 primary_id = GetPrimaryDisplay().id();
341  display_manager->SetDisplayRotation(primary_id, gfx::Display::ROTATE_90);
342  EXPECT_EQ(1, observer.CountAndReset());
343  display_manager->SetDisplayRotation(primary_id, gfx::Display::ROTATE_90);
344  EXPECT_EQ(0, observer.CountAndReset());
345
346  // UI scale is eanbled only on internal display.
347  int64 secondary_id = GetSecondaryDisplay().id();
348  gfx::Display::SetInternalDisplayId(secondary_id);
349  display_manager->SetDisplayUIScale(secondary_id, 1.125f);
350  EXPECT_EQ(1, observer.CountAndReset());
351  display_manager->SetDisplayUIScale(secondary_id, 1.125f);
352  EXPECT_EQ(0, observer.CountAndReset());
353  display_manager->SetDisplayUIScale(primary_id, 1.125f);
354  EXPECT_EQ(0, observer.CountAndReset());
355  display_manager->SetDisplayUIScale(primary_id, 1.125f);
356  EXPECT_EQ(0, observer.CountAndReset());
357}
358
359TEST_F(DisplayControllerTest, MirroredLayout) {
360  if (!SupportsMultipleDisplays())
361    return;
362
363  DisplayController* display_controller =
364      Shell::GetInstance()->display_controller();
365  UpdateDisplay("500x500,400x400");
366  EXPECT_FALSE(display_controller->GetCurrentDisplayLayout().mirrored);
367  EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
368  EXPECT_EQ(
369      2U, Shell::GetInstance()->display_manager()->num_connected_displays());
370
371  UpdateDisplay("1+0-500x500,1+0-500x500");
372  EXPECT_TRUE(display_controller->GetCurrentDisplayLayout().mirrored);
373  EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
374  EXPECT_EQ(
375      2U, Shell::GetInstance()->display_manager()->num_connected_displays());
376
377  UpdateDisplay("500x500,500x500");
378  EXPECT_FALSE(display_controller->GetCurrentDisplayLayout().mirrored);
379  EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
380  EXPECT_EQ(
381      2U, Shell::GetInstance()->display_manager()->num_connected_displays());
382}
383
384TEST_F(DisplayControllerTest, InvertLayout) {
385  EXPECT_EQ("left, 0",
386            DisplayLayout(DisplayLayout::RIGHT, 0).Invert().ToString());
387  EXPECT_EQ("left, -100",
388            DisplayLayout(DisplayLayout::RIGHT, 100).Invert().ToString());
389  EXPECT_EQ("left, 50",
390            DisplayLayout(DisplayLayout::RIGHT, -50).Invert().ToString());
391
392  EXPECT_EQ("right, 0",
393            DisplayLayout(DisplayLayout::LEFT, 0).Invert().ToString());
394  EXPECT_EQ("right, -90",
395            DisplayLayout(DisplayLayout::LEFT, 90).Invert().ToString());
396  EXPECT_EQ("right, 60",
397            DisplayLayout(DisplayLayout::LEFT, -60).Invert().ToString());
398
399  EXPECT_EQ("bottom, 0",
400            DisplayLayout(DisplayLayout::TOP, 0).Invert().ToString());
401  EXPECT_EQ("bottom, -80",
402            DisplayLayout(DisplayLayout::TOP, 80).Invert().ToString());
403  EXPECT_EQ("bottom, 70",
404            DisplayLayout(DisplayLayout::TOP, -70).Invert().ToString());
405
406  EXPECT_EQ("top, 0",
407            DisplayLayout(DisplayLayout::BOTTOM, 0).Invert().ToString());
408  EXPECT_EQ("top, -70",
409            DisplayLayout(DisplayLayout::BOTTOM, 70).Invert().ToString());
410  EXPECT_EQ("top, 80",
411            DisplayLayout(DisplayLayout::BOTTOM, -80).Invert().ToString());
412}
413
414TEST_F(DisplayControllerTest, SwapPrimary) {
415  if (!SupportsMultipleDisplays())
416    return;
417
418  DisplayController* display_controller =
419      Shell::GetInstance()->display_controller();
420
421  UpdateDisplay("200x200,300x300");
422  gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay();
423  gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay();
424
425  DisplayLayout display_layout(DisplayLayout::RIGHT, 50);
426  display_controller->SetLayoutForCurrentDisplays(display_layout);
427
428  EXPECT_NE(primary_display.id(), secondary_display.id());
429  aura::RootWindow* primary_root =
430      display_controller->GetRootWindowForDisplayId(primary_display.id());
431  aura::RootWindow* secondary_root =
432      display_controller->GetRootWindowForDisplayId(secondary_display.id());
433  EXPECT_NE(primary_root, secondary_root);
434  aura::Window* launcher_window =
435      Launcher::ForPrimaryDisplay()->shelf_widget()->GetNativeView();
436  EXPECT_TRUE(primary_root->Contains(launcher_window));
437  EXPECT_FALSE(secondary_root->Contains(launcher_window));
438  EXPECT_EQ(primary_display.id(),
439            Shell::GetScreen()->GetDisplayNearestPoint(
440                gfx::Point(-100, -100)).id());
441  EXPECT_EQ(primary_display.id(),
442            Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
443
444  EXPECT_EQ("0,0 200x200", primary_display.bounds().ToString());
445  EXPECT_EQ("0,0 200x152", primary_display.work_area().ToString());
446  EXPECT_EQ("200,0 300x300", secondary_display.bounds().ToString());
447  EXPECT_EQ("200,0 300x252", secondary_display.work_area().ToString());
448  EXPECT_EQ("right, 50",
449            display_controller->GetCurrentDisplayLayout().ToString());
450
451  // Switch primary and secondary
452  display_controller->SetPrimaryDisplay(secondary_display);
453  const DisplayLayout& inverted_layout =
454      display_controller->GetCurrentDisplayLayout();
455  EXPECT_EQ("left, -50", inverted_layout.ToString());
456
457  EXPECT_EQ(secondary_display.id(),
458            Shell::GetScreen()->GetPrimaryDisplay().id());
459  EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
460  EXPECT_EQ(secondary_display.id(),
461            Shell::GetScreen()->GetDisplayNearestPoint(
462                gfx::Point(-100, -100)).id());
463  EXPECT_EQ(secondary_display.id(),
464            Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
465
466  EXPECT_EQ(
467      primary_root,
468      display_controller->GetRootWindowForDisplayId(secondary_display.id()));
469  EXPECT_EQ(
470      secondary_root,
471      display_controller->GetRootWindowForDisplayId(primary_display.id()));
472  EXPECT_TRUE(primary_root->Contains(launcher_window));
473  EXPECT_FALSE(secondary_root->Contains(launcher_window));
474
475  // Test if the bounds are correctly swapped.
476  gfx::Display swapped_primary = Shell::GetScreen()->GetPrimaryDisplay();
477  gfx::Display swapped_secondary = ScreenAsh::GetSecondaryDisplay();
478  EXPECT_EQ("0,0 300x300", swapped_primary.bounds().ToString());
479  EXPECT_EQ("0,0 300x252", swapped_primary.work_area().ToString());
480  EXPECT_EQ("-200,-50 200x200", swapped_secondary.bounds().ToString());
481
482  EXPECT_EQ("-200,-50 200x152", swapped_secondary.work_area().ToString());
483
484  aura::WindowTracker tracker;
485  tracker.Add(primary_root);
486  tracker.Add(secondary_root);
487
488  // Deleting 2nd display should move the primary to original primary display.
489  UpdateDisplay("200x200");
490  RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
491  EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
492  EXPECT_EQ(primary_display.id(), Shell::GetScreen()->GetPrimaryDisplay().id());
493  EXPECT_EQ(primary_display.id(),
494            Shell::GetScreen()->GetDisplayNearestPoint(
495                gfx::Point(-100, -100)).id());
496  EXPECT_EQ(primary_display.id(),
497            Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
498  EXPECT_TRUE(tracker.Contains(primary_root));
499  EXPECT_FALSE(tracker.Contains(secondary_root));
500  EXPECT_TRUE(primary_root->Contains(launcher_window));
501}
502
503TEST_F(DisplayControllerTest, SwapPrimaryById) {
504  if (!SupportsMultipleDisplays())
505    return;
506
507  DisplayController* display_controller =
508      Shell::GetInstance()->display_controller();
509
510  UpdateDisplay("200x200,300x300");
511  gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay();
512  gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay();
513
514  DisplayLayout display_layout(DisplayLayout::RIGHT, 50);
515  display_controller->SetLayoutForCurrentDisplays(display_layout);
516
517  EXPECT_NE(primary_display.id(), secondary_display.id());
518  aura::RootWindow* primary_root =
519      display_controller->GetRootWindowForDisplayId(primary_display.id());
520  aura::RootWindow* secondary_root =
521      display_controller->GetRootWindowForDisplayId(secondary_display.id());
522  aura::Window* launcher_window =
523      Launcher::ForPrimaryDisplay()->shelf_widget()->GetNativeView();
524  EXPECT_TRUE(primary_root->Contains(launcher_window));
525  EXPECT_FALSE(secondary_root->Contains(launcher_window));
526  EXPECT_NE(primary_root, secondary_root);
527  EXPECT_EQ(primary_display.id(),
528            Shell::GetScreen()->GetDisplayNearestPoint(
529                gfx::Point(-100, -100)).id());
530  EXPECT_EQ(primary_display.id(),
531            Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
532
533  // Switch primary and secondary by display ID.
534  TestObserver observer;
535  display_controller->SetPrimaryDisplayId(secondary_display.id());
536  EXPECT_EQ(secondary_display.id(),
537            Shell::GetScreen()->GetPrimaryDisplay().id());
538  EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
539  EXPECT_LT(0, observer.CountAndReset());
540
541  EXPECT_EQ(
542      primary_root,
543      display_controller->GetRootWindowForDisplayId(secondary_display.id()));
544  EXPECT_EQ(
545      secondary_root,
546      display_controller->GetRootWindowForDisplayId(primary_display.id()));
547  EXPECT_TRUE(primary_root->Contains(launcher_window));
548  EXPECT_FALSE(secondary_root->Contains(launcher_window));
549
550  const DisplayLayout& inverted_layout =
551      display_controller->GetCurrentDisplayLayout();
552
553  EXPECT_EQ("left, -50", inverted_layout.ToString());
554
555  // Calling the same ID don't do anything.
556  display_controller->SetPrimaryDisplayId(secondary_display.id());
557  EXPECT_EQ(0, observer.CountAndReset());
558
559  aura::WindowTracker tracker;
560  tracker.Add(primary_root);
561  tracker.Add(secondary_root);
562
563  // Deleting 2nd display should move the primary to original primary display.
564  UpdateDisplay("200x200");
565  RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
566  EXPECT_EQ(1, Shell::GetScreen()->GetNumDisplays());
567  EXPECT_EQ(primary_display.id(), Shell::GetScreen()->GetPrimaryDisplay().id());
568  EXPECT_EQ(primary_display.id(),
569            Shell::GetScreen()->GetDisplayNearestPoint(
570                gfx::Point(-100, -100)).id());
571  EXPECT_EQ(primary_display.id(),
572            Shell::GetScreen()->GetDisplayNearestWindow(NULL).id());
573  EXPECT_TRUE(tracker.Contains(primary_root));
574  EXPECT_FALSE(tracker.Contains(secondary_root));
575  EXPECT_TRUE(primary_root->Contains(launcher_window));
576
577  internal::DisplayManager* display_manager =
578      Shell::GetInstance()->display_manager();
579  // Adding 2nd display with the same ID.  The 2nd display should become primary
580  // since secondary id is still stored as desirable_primary_id.
581  std::vector<internal::DisplayInfo> display_info_list;
582  display_info_list.push_back(
583      display_manager->GetDisplayInfo(primary_display.id()));
584  display_info_list.push_back(
585      display_manager->GetDisplayInfo(secondary_display.id()));
586  display_manager->OnNativeDisplaysChanged(display_info_list);
587
588  EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
589  EXPECT_EQ(secondary_display.id(),
590            Shell::GetScreen()->GetPrimaryDisplay().id());
591  EXPECT_EQ(primary_display.id(), ScreenAsh::GetSecondaryDisplay().id());
592  EXPECT_EQ(
593      primary_root,
594      display_controller->GetRootWindowForDisplayId(secondary_display.id()));
595  EXPECT_NE(
596      primary_root,
597      display_controller->GetRootWindowForDisplayId(primary_display.id()));
598  EXPECT_TRUE(primary_root->Contains(launcher_window));
599
600  // Deleting 2nd display and adding 2nd display with a different ID.  The 2nd
601  // display shouldn't become primary.
602  UpdateDisplay("200x200");
603  internal::DisplayInfo third_display_info(
604      secondary_display.id() + 1, std::string(), false);
605  third_display_info.SetBounds(secondary_display.bounds());
606  ASSERT_NE(primary_display.id(), third_display_info.id());
607
608  const internal::DisplayInfo& primary_display_info =
609      display_manager->GetDisplayInfo(primary_display.id());
610  std::vector<internal::DisplayInfo> display_info_list2;
611  display_info_list2.push_back(primary_display_info);
612  display_info_list2.push_back(third_display_info);
613  display_manager->OnNativeDisplaysChanged(display_info_list2);
614  EXPECT_EQ(2, Shell::GetScreen()->GetNumDisplays());
615  EXPECT_EQ(primary_display.id(),
616            Shell::GetScreen()->GetPrimaryDisplay().id());
617  EXPECT_EQ(third_display_info.id(), ScreenAsh::GetSecondaryDisplay().id());
618  EXPECT_EQ(
619      primary_root,
620      display_controller->GetRootWindowForDisplayId(primary_display.id()));
621  EXPECT_NE(
622      primary_root,
623      display_controller->GetRootWindowForDisplayId(third_display_info.id()));
624  EXPECT_TRUE(primary_root->Contains(launcher_window));
625}
626
627TEST_F(DisplayControllerTest, CursorDeviceScaleFactorSwapPrimary) {
628  if (!SupportsMultipleDisplays())
629    return;
630
631  DisplayController* display_controller =
632      Shell::GetInstance()->display_controller();
633
634  UpdateDisplay("200x200,200x200*2");
635  gfx::Display primary_display = Shell::GetScreen()->GetPrimaryDisplay();
636  gfx::Display secondary_display = ScreenAsh::GetSecondaryDisplay();
637
638  aura::RootWindow* primary_root =
639      display_controller->GetRootWindowForDisplayId(primary_display.id());
640  aura::RootWindow* secondary_root =
641      display_controller->GetRootWindowForDisplayId(secondary_display.id());
642  EXPECT_NE(primary_root, secondary_root);
643
644  test::CursorManagerTestApi test_api(Shell::GetInstance()->cursor_manager());
645
646  EXPECT_EQ(1.0f,
647            primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
648  primary_root->MoveCursorTo(gfx::Point(50, 50));
649  EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor());
650  EXPECT_EQ(2.0f,
651            secondary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
652  secondary_root->MoveCursorTo(gfx::Point(50, 50));
653  EXPECT_EQ(2.0f, test_api.GetDisplay().device_scale_factor());
654
655  // Switch primary and secondary
656  display_controller->SetPrimaryDisplay(secondary_display);
657
658  // Cursor's device scale factor should be updated accroding to the swap of
659  // primary and secondary.
660  EXPECT_EQ(1.0f,
661            secondary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
662  secondary_root->MoveCursorTo(gfx::Point(50, 50));
663  EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor());
664  primary_root->MoveCursorTo(gfx::Point(50, 50));
665  EXPECT_EQ(2.0f,
666            primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
667  EXPECT_EQ(2.0f, test_api.GetDisplay().device_scale_factor());
668
669  // Deleting 2nd display.
670  UpdateDisplay("200x200");
671  RunAllPendingInMessageLoop();  // RootWindow is deleted in a posted task.
672
673  // Cursor's device scale factor should be updated even without moving cursor.
674  EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor());
675
676  primary_root->MoveCursorTo(gfx::Point(50, 50));
677  EXPECT_EQ(1.0f,
678            primary_root->AsRootWindowHostDelegate()->GetDeviceScaleFactor());
679  EXPECT_EQ(1.0f, test_api.GetDisplay().device_scale_factor());
680}
681
682#if defined(OS_WIN)
683// TODO(scottmg): RootWindow doesn't get resized on Windows
684// Ash. http://crbug.com/247916.
685#define MAYBE_UpdateDisplayWithHostOrigin DISABLED_UpdateDisplayWithHostOrigin
686#else
687#define MAYBE_UpdateDisplayWithHostOrigin UpdateDisplayWithHostOrigin
688#endif
689
690TEST_F(DisplayControllerTest, MAYBE_UpdateDisplayWithHostOrigin) {
691  UpdateDisplay("100x200,300x400");
692  ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
693  Shell::RootWindowList root_windows =
694      Shell::GetInstance()->GetAllRootWindows();
695  ASSERT_EQ(2U, root_windows.size());
696  EXPECT_EQ("1,1", root_windows[0]->GetHostOrigin().ToString());
697  EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
698  // UpdateDisplay set the origin if it's not set.
699  EXPECT_NE("1,1", root_windows[1]->GetHostOrigin().ToString());
700  EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
701
702  UpdateDisplay("100x200,200+300-300x400");
703  ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
704  EXPECT_EQ("0,0", root_windows[0]->GetHostOrigin().ToString());
705  EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
706  EXPECT_EQ("200,300", root_windows[1]->GetHostOrigin().ToString());
707  EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
708
709  UpdateDisplay("400+500-200x300,300x400");
710  ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
711  EXPECT_EQ("400,500", root_windows[0]->GetHostOrigin().ToString());
712  EXPECT_EQ("200x300", root_windows[0]->GetHostSize().ToString());
713  EXPECT_EQ("0,0", root_windows[1]->GetHostOrigin().ToString());
714  EXPECT_EQ("300x400", root_windows[1]->GetHostSize().ToString());
715
716  UpdateDisplay("100+200-100x200,300+500-200x300");
717  ASSERT_EQ(2, Shell::GetScreen()->GetNumDisplays());
718  EXPECT_EQ("100,200", root_windows[0]->GetHostOrigin().ToString());
719  EXPECT_EQ("100x200", root_windows[0]->GetHostSize().ToString());
720  EXPECT_EQ("300,500", root_windows[1]->GetHostOrigin().ToString());
721  EXPECT_EQ("200x300", root_windows[1]->GetHostSize().ToString());
722}
723
724TEST_F(DisplayControllerTest, OverscanInsets) {
725  if (!SupportsMultipleDisplays())
726    return;
727
728  DisplayController* display_controller =
729      Shell::GetInstance()->display_controller();
730  TestEventHandler event_handler;
731  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
732
733  UpdateDisplay("120x200,300x400*2");
734  gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay();
735  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
736
737  display_controller->SetOverscanInsets(display1.id(),
738                                        gfx::Insets(10, 15, 20, 25));
739  EXPECT_EQ("0,0 80x170", root_windows[0]->bounds().ToString());
740  EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
741  EXPECT_EQ("80,0 150x200",
742            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
743
744  aura::test::EventGenerator generator(root_windows[0]);
745  generator.MoveMouseToInHost(20, 25);
746  EXPECT_EQ("5,15", event_handler.GetLocationAndReset());
747
748  display_controller->SetOverscanInsets(display1.id(), gfx::Insets());
749  EXPECT_EQ("0,0 120x200", root_windows[0]->bounds().ToString());
750  EXPECT_EQ("120,0 150x200",
751            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
752
753  generator.MoveMouseToInHost(30, 20);
754  EXPECT_EQ("30,20", event_handler.GetLocationAndReset());
755
756  // Make sure the root window transformer uses correct scale
757  // factor when swapping display. Test crbug.com/253690.
758  UpdateDisplay("400x300*2,600x400/o");
759  root_windows = Shell::GetAllRootWindows();
760  gfx::Point point;
761  Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(point);
762  EXPECT_EQ("15,10", point.ToString());
763
764  display_controller->SwapPrimaryDisplay();
765  point.SetPoint(0, 0);
766  Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(point);
767  EXPECT_EQ("15,10", point.ToString());
768
769  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
770}
771
772TEST_F(DisplayControllerTest, Rotate) {
773  if (!SupportsMultipleDisplays())
774    return;
775
776  DisplayController* display_controller =
777      Shell::GetInstance()->display_controller();
778  internal::DisplayManager* display_manager =
779      Shell::GetInstance()->display_manager();
780  TestEventHandler event_handler;
781  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
782
783  UpdateDisplay("120x200,300x400*2");
784  gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay();
785  int64 display2_id = ScreenAsh::GetSecondaryDisplay().id();
786  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
787  aura::test::EventGenerator generator1(root_windows[0]);
788
789  EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString());
790  EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
791  EXPECT_EQ("120,0 150x200",
792            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
793  generator1.MoveMouseToInHost(50, 40);
794  EXPECT_EQ("50,40", event_handler.GetLocationAndReset());
795  EXPECT_EQ(gfx::Display::ROTATE_0, GetStoredRotation(display1.id()));
796  EXPECT_EQ(gfx::Display::ROTATE_0, GetStoredRotation(display2_id));
797
798  display_manager->SetDisplayRotation(display1.id(),
799                                      gfx::Display::ROTATE_90);
800  EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString());
801  EXPECT_EQ("150x200", root_windows[1]->bounds().size().ToString());
802  EXPECT_EQ("200,0 150x200",
803            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
804  generator1.MoveMouseToInHost(50, 40);
805  EXPECT_EQ("40,69", event_handler.GetLocationAndReset());
806  EXPECT_EQ(gfx::Display::ROTATE_90, GetStoredRotation(display1.id()));
807  EXPECT_EQ(gfx::Display::ROTATE_0, GetStoredRotation(display2_id));
808
809  DisplayLayout display_layout(DisplayLayout::BOTTOM, 50);
810  display_controller->SetLayoutForCurrentDisplays(display_layout);
811  EXPECT_EQ("50,120 150x200",
812            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
813
814  display_manager->SetDisplayRotation(display2_id,
815                                      gfx::Display::ROTATE_270);
816  EXPECT_EQ("200x120", root_windows[0]->bounds().size().ToString());
817  EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString());
818  EXPECT_EQ("50,120 200x150",
819            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
820  EXPECT_EQ(gfx::Display::ROTATE_90, GetStoredRotation(display1.id()));
821  EXPECT_EQ(gfx::Display::ROTATE_270, GetStoredRotation(display2_id));
822
823#if !defined(OS_WIN)
824  aura::test::EventGenerator generator2(root_windows[1]);
825  generator2.MoveMouseToInHost(50, 40);
826  EXPECT_EQ("179,25", event_handler.GetLocationAndReset());
827  display_manager->SetDisplayRotation(display1.id(),
828                                      gfx::Display::ROTATE_180);
829
830  EXPECT_EQ("120x200", root_windows[0]->bounds().size().ToString());
831  EXPECT_EQ("200x150", root_windows[1]->bounds().size().ToString());
832  // Dislay must share at least 100, so the x's offset becomes 20.
833  EXPECT_EQ("20,200 200x150",
834            ScreenAsh::GetSecondaryDisplay().bounds().ToString());
835  EXPECT_EQ(gfx::Display::ROTATE_180, GetStoredRotation(display1.id()));
836  EXPECT_EQ(gfx::Display::ROTATE_270, GetStoredRotation(display2_id));
837
838  generator1.MoveMouseToInHost(50, 40);
839  EXPECT_EQ("69,159", event_handler.GetLocationAndReset());
840#endif
841
842  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
843}
844
845TEST_F(DisplayControllerTest, ScaleRootWindow) {
846  if (!SupportsMultipleDisplays())
847    return;
848
849  TestEventHandler event_handler;
850  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
851
852  UpdateDisplay("600x400*2@1.5,500x300");
853
854  gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay();
855  gfx::Display::SetInternalDisplayId(display1.id());
856
857  gfx::Display display2 = ScreenAsh::GetSecondaryDisplay();
858  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
859  EXPECT_EQ("0,0 450x300", display1.bounds().ToString());
860  EXPECT_EQ("0,0 450x300", root_windows[0]->bounds().ToString());
861  EXPECT_EQ("450,0 500x300", display2.bounds().ToString());
862  EXPECT_EQ(1.5f, GetStoredUIScale(display1.id()));
863  EXPECT_EQ(1.0f, GetStoredUIScale(display2.id()));
864
865  aura::test::EventGenerator generator(root_windows[0]);
866  generator.MoveMouseToInHost(599, 200);
867  EXPECT_EQ("449,150", event_handler.GetLocationAndReset());
868
869  internal::DisplayManager* display_manager =
870      Shell::GetInstance()->display_manager();
871  display_manager->SetDisplayUIScale(display1.id(), 1.25f);
872  display1 = Shell::GetScreen()->GetPrimaryDisplay();
873  display2 = ScreenAsh::GetSecondaryDisplay();
874  EXPECT_EQ("0,0 375x250", display1.bounds().ToString());
875  EXPECT_EQ("0,0 375x250", root_windows[0]->bounds().ToString());
876  EXPECT_EQ("375,0 500x300", display2.bounds().ToString());
877  EXPECT_EQ(1.25f, GetStoredUIScale(display1.id()));
878  EXPECT_EQ(1.0f, GetStoredUIScale(display2.id()));
879
880  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
881}
882
883TEST_F(DisplayControllerTest, TouchScale) {
884  if (!SupportsMultipleDisplays())
885    return;
886
887  TestEventHandler event_handler;
888  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
889
890  UpdateDisplay("200x200*2");
891  gfx::Display display = Shell::GetScreen()->GetPrimaryDisplay();
892  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
893  aura::RootWindow* root_window = root_windows[0];
894  aura::test::EventGenerator generator(root_window);
895
896  generator.PressMoveAndReleaseTouchTo(50, 50);
897  // Default test touches have radius_x/y = 1.0, with device scale
898  // factor = 2, the scaled radius_x/y should be 0.5.
899  EXPECT_EQ(0.5, event_handler.touch_radius_x());
900  EXPECT_EQ(0.5, event_handler.touch_radius_y());
901
902  generator.ScrollSequence(gfx::Point(0,0),
903                           base::TimeDelta::FromMilliseconds(100),
904                           10.0, 1.0, 5, 1);
905
906  // With device scale factor = 2, ordinal_offset * 2 = offset.
907  EXPECT_EQ(event_handler.scroll_x_offset(),
908            event_handler.scroll_x_offset_ordinal() * 2);
909  EXPECT_EQ(event_handler.scroll_y_offset(),
910            event_handler.scroll_y_offset_ordinal() * 2);
911
912  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
913}
914
915TEST_F(DisplayControllerTest, ConvertHostToRootCoords) {
916  if (!SupportsMultipleDisplays())
917    return;
918
919  TestEventHandler event_handler;
920  Shell::GetInstance()->AddPreTargetHandler(&event_handler);
921
922  UpdateDisplay("600x400*2/r@1.5");
923
924  gfx::Display display1 = Shell::GetScreen()->GetPrimaryDisplay();
925  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
926  EXPECT_EQ("0,0 300x450", display1.bounds().ToString());
927  EXPECT_EQ("0,0 300x450", root_windows[0]->bounds().ToString());
928  EXPECT_EQ(1.5f, GetStoredUIScale(display1.id()));
929
930  aura::test::EventGenerator generator(root_windows[0]);
931  generator.MoveMouseToInHost(0, 0);
932  EXPECT_EQ("0,449", event_handler.GetLocationAndReset());
933  generator.MoveMouseToInHost(599, 0);
934  EXPECT_EQ("0,0", event_handler.GetLocationAndReset());
935  generator.MoveMouseToInHost(599, 399);
936  EXPECT_EQ("299,0", event_handler.GetLocationAndReset());
937  generator.MoveMouseToInHost(0, 399);
938  EXPECT_EQ("299,449", event_handler.GetLocationAndReset());
939
940  UpdateDisplay("600x400*2/u@1.5");
941  display1 = Shell::GetScreen()->GetPrimaryDisplay();
942  root_windows = Shell::GetAllRootWindows();
943  EXPECT_EQ("0,0 450x300", display1.bounds().ToString());
944  EXPECT_EQ("0,0 450x300", root_windows[0]->bounds().ToString());
945  EXPECT_EQ(1.5f, GetStoredUIScale(display1.id()));
946
947  generator.MoveMouseToInHost(0, 0);
948  EXPECT_EQ("449,299", event_handler.GetLocationAndReset());
949  generator.MoveMouseToInHost(599, 0);
950  EXPECT_EQ("0,299", event_handler.GetLocationAndReset());
951  generator.MoveMouseToInHost(599, 399);
952  EXPECT_EQ("0,0", event_handler.GetLocationAndReset());
953  generator.MoveMouseToInHost(0, 399);
954  EXPECT_EQ("449,0", event_handler.GetLocationAndReset());
955
956  UpdateDisplay("600x400*2/l@1.5");
957  display1 = Shell::GetScreen()->GetPrimaryDisplay();
958  root_windows = Shell::GetAllRootWindows();
959  EXPECT_EQ("0,0 300x450", display1.bounds().ToString());
960  EXPECT_EQ("0,0 300x450", root_windows[0]->bounds().ToString());
961  EXPECT_EQ(1.5f, GetStoredUIScale(display1.id()));
962
963  generator.MoveMouseToInHost(0, 0);
964  EXPECT_EQ("299,0", event_handler.GetLocationAndReset());
965  generator.MoveMouseToInHost(599, 0);
966  EXPECT_EQ("299,449", event_handler.GetLocationAndReset());
967  generator.MoveMouseToInHost(599, 399);
968  EXPECT_EQ("0,449", event_handler.GetLocationAndReset());
969  generator.MoveMouseToInHost(0, 399);
970  EXPECT_EQ("0,0", event_handler.GetLocationAndReset());
971
972  Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
973}
974
975#if defined(USE_X11)
976TEST_F(DisplayControllerTest, XWidowNameForRootWindow) {
977  EXPECT_EQ("aura_root_0", GetXWindowName(Shell::GetPrimaryRootWindow()));
978
979  // Multiple display.
980  UpdateDisplay("200x200,300x300");
981  aura::RootWindow* primary, *secondary;
982  GetPrimaryAndSeconary(&primary, &secondary);
983  EXPECT_EQ("aura_root_0", GetXWindowName(primary));
984  EXPECT_EQ("aura_root_x", GetXWindowName(secondary));
985
986  // Swap primary.
987  primary = secondary = NULL;
988  Shell::GetInstance()->display_controller()->SwapPrimaryDisplay();
989  GetPrimaryAndSeconary(&primary, &secondary);
990  EXPECT_EQ("aura_root_0", GetXWindowName(primary));
991  EXPECT_EQ("aura_root_x", GetXWindowName(secondary));
992
993  // Switching back to single display.
994  UpdateDisplay("300x400");
995  EXPECT_EQ("aura_root_0", GetXWindowName(Shell::GetPrimaryRootWindow()));
996}
997#endif
998
999}  // namespace test
1000}  // namespace ash
1001