Aura: Switch window mode when screen resolution changes

ash/shell.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/shell.h"
 
 #include <algorithm>
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_filter.h"
@@ skipping 39 matching lines @@
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 
 namespace {
 
+using aura::Window;
 using views::Widget;
 
 // Screen width at or below which we automatically start in compact window mode,
 // in pixels. Should be at least 1366 pixels, the resolution of ChromeOS ZGB
 // device displays, as we traditionally used a single window on those devices.
 const int kCompactWindowModeWidthThreshold = 1366;
 
 // Creates each of the special window containers that holds windows of various
 // types in the shell UI. They are added to |containers| from back to front in
 // the z-index.
@@ skipping 109 matching lines @@
 
 Shell::Shell(ShellDelegate* delegate)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       accelerator_controller_(new AcceleratorController),
       delegate_(delegate),
       window_mode_(MODE_OVERLAPPING),
       root_window_layout_(NULL),
       status_widget_(NULL) {
   aura::RootWindow::GetInstance()->SetEventFilter(
       new internal::RootWindowEventFilter);
+  aura::RootWindow::GetInstance()->AddRootWindowObserver(this);
 }
 
 Shell::~Shell() {
+  aura::RootWindow::GetInstance()->RemoveRootWindowObserver(this);
   RemoveRootWindowEventFilter(input_method_filter_.get());
   RemoveRootWindowEventFilter(window_modality_controller_.get());
   RemoveRootWindowEventFilter(accelerator_filter_.get());
 
   // TooltipController needs a valid shell instance. We delete it before
   // deleting the shell |instance_|.
   RemoveRootWindowEventFilter(tooltip_controller_.get());
   aura::client::SetTooltipClient(NULL);
 
   // The LayoutManagers for the default and status containers talk to
@@ skipping 43 matching lines @@
   DCHECK(instance_);
   return instance_;
 }
 
 // static
 void Shell::DeleteInstance() {
   delete instance_;
   instance_ = NULL;
 }
 
+void Shell::OnRootWindowResized(const gfx::Size& new_size) {
+  // Developers often run the Aura shell in small windows on their desktop.
+  // Don't switch window modes for them.
+  if (!aura::RootWindow::use_fullscreen_host_window())
+    return;
+
+  // If we're running on a device, a resize event means the user plugged in or
+  // unplugged an external monitor. Change window mode to be appropriate for
+  // the new screen resolution.
+  gfx::Size monitor_size = gfx::Screen::GetPrimaryMonitorSize();
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  WindowMode new_mode = ComputeWindowMode(monitor_size, command_line);
+  ChangeWindowMode(new_mode);
+}
+
 void Shell::Init() {
   // InputMethodEventFilter must be added first since it has the highest
   // priority.
   DCHECK(!GetRootWindowEventFilterCount());
   input_method_filter_.reset(new internal::InputMethodEventFilter);
   AddRootWindowEventFilter(input_method_filter_.get());
 
   // On small screens we automatically enable --aura-window-mode=compact if the
   // user has not explicitly set a window mode flag. This must happen before
   // we create containers or layout managers.
@@ skipping 129 matching lines @@
 
 void Shell::ChangeWindowMode(WindowMode mode) {
   if (mode == window_mode_)
     return;
   // Window mode must be set before we resize/layout the windows.
   window_mode_ = mode;
   if (window_mode_ == MODE_COMPACT)
     SetupCompactWindowMode();
   else
     SetupNonCompactWindowMode();
-  // Force a layout.
-  aura::RootWindow::GetInstance()->layout_manager()->OnWindowResized();
+  // Force a layout of all containers.
+  aura::RootWindow* root_window = aura::RootWindow::GetInstance();
+  root_window->layout_manager()->OnWindowResized();
+  for (Window::Windows::const_iterator it = root_window->children().begin();

[sky, 2012/02/03 21:47:42]

Don't the children handle this themselves?

[James Cook, 2012/02/03 22:02:44]

They do, but too early for it to be useful for me.  By the time I get the
OnRootWindowResized() call in Shell the children have already had their bounds
set and OnWindowResized called.  Do you think the window-mode-selection code
should be triggered by RootWindowLayoutManager::OnWindowResized() so it can
happen before child bounds are set?

+       it != root_window->children().end();
+       ++it) {
+    if ((*it)->layout_manager())
+      (*it)->layout_manager()->OnWindowResized();
+  }
 }
 
 bool Shell::IsScreenLocked() const {
   const aura::Window* lock_screen_container = GetContainer(
       internal::kShellWindowId_LockScreenContainer);
   return lock_screen_container->StopsEventPropagation();
 }
 
 bool Shell::IsModalWindowOpen() const {
   aura::Window* modal_container =
@@ skipping 97 matching lines @@
 
   // Create the desktop background image.
   root_window_layout_->SetBackgroundWidget(internal::CreateDesktopBackground());
 }
 
 void Shell::ResetLayoutManager(int container_id) {
   GetContainer(container_id)->SetLayoutManager(NULL);
 }
 
 }  // namespace ash