src/apps/shell/browser/shell_desktop_controller.cc

   1 // Copyright 2014 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 "apps/shell/browser/shell_desktop_controller.h"
   6
   7 #include "apps/shell/browser/shell_app_window_controller.h"
   8 #include "content/public/browser/context_factory.h"
   9 #include "ui/aura/client/cursor_client.h"
  10 #include "ui/aura/client/default_capture_client.h"
  11 #include "ui/aura/env.h"
  12 #include "ui/aura/layout_manager.h"
  13 #include "ui/aura/test/test_screen.h"
  14 #include "ui/aura/window.h"
  15 #include "ui/aura/window_event_dispatcher.h"
  16 #include "ui/aura/window_tree_host.h"
  17 #include "ui/base/cursor/cursor.h"
  18 #include "ui/base/cursor/image_cursors.h"
  19 #include "ui/base/ime/input_method_initializer.h"
  20 #include "ui/gfx/native_widget_types.h"
  21 #include "ui/gfx/screen.h"
  22 #include "ui/wm/core/base_focus_rules.h"
  23 #include "ui/wm/core/compound_event_filter.h"
  24 #include "ui/wm/core/cursor_manager.h"
  25 #include "ui/wm/core/focus_controller.h"
  26 #include "ui/wm/core/input_method_event_filter.h"
  27 #include "ui/wm/core/native_cursor_manager.h"
  28 #include "ui/wm/core/native_cursor_manager_delegate.h"
  29 #include "ui/wm/core/user_activity_detector.h"
  30
  31 #if defined(OS_CHROMEOS)
  32 #include "ui/chromeos/user_activity_power_manager_notifier.h"
  33 #include "ui/display/types/chromeos/display_mode.h"
  34 #include "ui/display/types/chromeos/display_snapshot.h"
  35 #endif
  36
  37 namespace apps {
  38 namespace {
  39
  40 // A simple layout manager that makes each new window fill its parent.
  41 class FillLayout : public aura::LayoutManager {
  42  public:
  43   FillLayout() {}
  44   virtual ~FillLayout() {}
  45
  46  private:
  47   // aura::LayoutManager:
  48   virtual void OnWindowResized() OVERRIDE {}
  49
  50   virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
  51     if (!child->parent())
  52       return;
  53
  54     // Create a rect at 0,0 with the size of the parent.
  55     gfx::Size parent_size = child->parent()->bounds().size();
  56     child->SetBounds(gfx::Rect(parent_size));
  57   }
  58
  59   virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {}
  60
  61   virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {}
  62
  63   virtual void OnChildWindowVisibilityChanged(aura::Window* child,
  64                                               bool visible) OVERRIDE {}
  65
  66   virtual void SetChildBounds(aura::Window* child,
  67                               const gfx::Rect& requested_bounds) OVERRIDE {
  68     SetChildBoundsDirect(child, requested_bounds);
  69   }
  70
  71   DISALLOW_COPY_AND_ASSIGN(FillLayout);
  72 };
  73
  74 // A class that bridges the gap between CursorManager and Aura. It borrows
  75 // heavily from AshNativeCursorManager.
  76 class ShellNativeCursorManager : public wm::NativeCursorManager {
  77  public:
  78   explicit ShellNativeCursorManager(aura::WindowTreeHost* host)
  79       : host_(host),
  80         image_cursors_(new ui::ImageCursors) {}
  81   virtual ~ShellNativeCursorManager() {}
  82
  83   // wm::NativeCursorManager overrides.
  84   virtual void SetDisplay(
  85       const gfx::Display& display,
  86       wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
  87     if (image_cursors_->SetDisplay(display, display.device_scale_factor()))
  88       SetCursor(delegate->GetCursor(), delegate);
  89   }
  90
  91   virtual void SetCursor(
  92       gfx::NativeCursor cursor,
  93       wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
  94     image_cursors_->SetPlatformCursor(&cursor);
  95     cursor.set_device_scale_factor(image_cursors_->GetScale());
  96     delegate->CommitCursor(cursor);
  97
  98     if (delegate->IsCursorVisible())
  99       ApplyCursor(cursor);
 100   }
 101
 102   virtual void SetVisibility(
 103       bool visible,
 104       wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
 105     delegate->CommitVisibility(visible);
 106
 107     if (visible) {
 108       SetCursor(delegate->GetCursor(), delegate);
 109     } else {
 110       gfx::NativeCursor invisible_cursor(ui::kCursorNone);
 111       image_cursors_->SetPlatformCursor(&invisible_cursor);
 112       ApplyCursor(invisible_cursor);
 113     }
 114   }
 115
 116   virtual void SetCursorSet(
 117       ui::CursorSetType cursor_set,
 118       wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
 119     image_cursors_->SetCursorSet(cursor_set);
 120     delegate->CommitCursorSet(cursor_set);
 121     if (delegate->IsCursorVisible())
 122       SetCursor(delegate->GetCursor(), delegate);
 123   }
 124
 125   virtual void SetMouseEventsEnabled(
 126       bool enabled,
 127       wm::NativeCursorManagerDelegate* delegate) OVERRIDE {
 128     delegate->CommitMouseEventsEnabled(enabled);
 129     SetVisibility(delegate->IsCursorVisible(), delegate);
 130   }
 131
 132  private:
 133   // Sets |cursor| as the active cursor within Aura.
 134   void ApplyCursor(gfx::NativeCursor cursor) {
 135     host_->SetCursor(cursor);
 136   }
 137
 138   aura::WindowTreeHost* host_;  // Not owned.
 139
 140   scoped_ptr<ui::ImageCursors> image_cursors_;
 141
 142   DISALLOW_COPY_AND_ASSIGN(ShellNativeCursorManager);
 143 };
 144
 145 class AppsFocusRules : public wm::BaseFocusRules {
 146  public:
 147   AppsFocusRules() {}
 148   virtual ~AppsFocusRules() {}
 149
 150   virtual bool SupportsChildActivation(aura::Window* window) const OVERRIDE {
 151     return true;
 152   }
 153
 154  private:
 155   DISALLOW_COPY_AND_ASSIGN(AppsFocusRules);
 156 };
 157
 158 ShellDesktopController* g_instance = NULL;
 159
 160 }  // namespace
 161
 162 ShellDesktopController::ShellDesktopController() {
 163 #if defined(OS_CHROMEOS)
 164   display_configurator_.reset(new ui::DisplayConfigurator);
 165   display_configurator_->Init(false);
 166   display_configurator_->ForceInitialConfigure(0);
 167   display_configurator_->AddObserver(this);
 168 #endif
 169   aura::Env::CreateInstance(true);
 170   aura::Env::GetInstance()->set_context_factory(content::GetContextFactory());
 171
 172   g_instance = this;
 173 }
 174
 175 ShellDesktopController::~ShellDesktopController() {
 176   app_window_controller_.reset();
 177   g_instance = NULL;
 178   DestroyRootWindow();
 179   aura::Env::DeleteInstance();
 180 }
 181
 182 // static
 183 ShellDesktopController* ShellDesktopController::instance() {
 184   return g_instance;
 185 }
 186
 187 void ShellDesktopController::SetAppWindowController(
 188     ShellAppWindowController* app_window_controller) {
 189   app_window_controller_.reset(app_window_controller);
 190 }
 191
 192 ShellAppWindow* ShellDesktopController::CreateAppWindow(
 193     content::BrowserContext* context) {
 194   return app_window_controller_->CreateAppWindow(context);
 195 }
 196
 197 void ShellDesktopController::CloseAppWindows() {
 198   if (app_window_controller_)
 199     app_window_controller_->CloseAppWindows();
 200 }
 201
 202 aura::Window* ShellDesktopController::GetDefaultParent(
 203     aura::Window* context,
 204     aura::Window* window,
 205     const gfx::Rect& bounds) {
 206   return host_->window();
 207 }
 208
 209 #if defined(OS_CHROMEOS)
 210 void ShellDesktopController::OnDisplayModeChanged(
 211     const std::vector<ui::DisplayConfigurator::DisplayState>& displays) {
 212   gfx::Size size = GetPrimaryDisplaySize();
 213   if (!size.IsEmpty())
 214     host_->UpdateRootWindowSize(size);
 215 }
 216 #endif
 217
 218 void ShellDesktopController::OnHostCloseRequested(
 219     const aura::WindowTreeHost* host) {
 220   DCHECK_EQ(host_.get(), host);
 221   CloseAppWindows();
 222   base::MessageLoop::current()->PostTask(FROM_HERE,
 223                                          base::MessageLoop::QuitClosure());
 224 }
 225
 226 void ShellDesktopController::CreateRootWindow() {
 227   // Set up basic pieces of ui::wm.
 228   gfx::Size size = GetPrimaryDisplaySize();
 229   if (size.IsEmpty())
 230     size = gfx::Size(1280, 720);
 231
 232   test_screen_.reset(aura::TestScreen::Create(size));
 233   // TODO(jamescook): Replace this with a real Screen implementation.
 234   gfx::Screen::SetScreenInstance(gfx::SCREEN_TYPE_NATIVE, test_screen_.get());
 235   // TODO(mukai): Set up input method.
 236
 237   host_.reset(aura::WindowTreeHost::Create(gfx::Rect(size)));
 238   host_->InitHost();
 239   aura::client::SetWindowTreeClient(host_->window(), this);
 240   root_window_event_filter_.reset(new wm::CompoundEventFilter);
 241   host_->window()->AddPreTargetHandler(root_window_event_filter_.get());
 242   InitWindowManager();
 243
 244   host_->AddObserver(this);
 245
 246   // Ensure the X window gets mapped.
 247   host_->Show();
 248 }
 249
 250 void ShellDesktopController::InitWindowManager() {
 251   wm::FocusController* focus_controller =
 252       new wm::FocusController(new AppsFocusRules());
 253   aura::client::SetFocusClient(host_->window(), focus_controller);
 254   host_->window()->AddPreTargetHandler(focus_controller);
 255   aura::client::SetActivationClient(host_->window(), focus_controller);
 256   focus_client_.reset(focus_controller);
 257
 258   input_method_filter_.reset(
 259       new wm::InputMethodEventFilter(host_->GetAcceleratedWidget()));
 260   input_method_filter_->SetInputMethodPropertyInRootWindow(host_->window());
 261   root_window_event_filter_->AddHandler(input_method_filter_.get());
 262
 263   capture_client_.reset(
 264       new aura::client::DefaultCaptureClient(host_->window()));
 265
 266   // Ensure new windows fill the display.
 267   host_->window()->SetLayoutManager(new FillLayout);
 268
 269   cursor_manager_.reset(
 270       new wm::CursorManager(scoped_ptr<wm::NativeCursorManager>(
 271           new ShellNativeCursorManager(host_.get()))));
 272   cursor_manager_->SetDisplay(
 273       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay());
 274   cursor_manager_->SetCursor(ui::kCursorPointer);
 275   aura::client::SetCursorClient(host_->window(), cursor_manager_.get());
 276
 277   user_activity_detector_.reset(new wm::UserActivityDetector);
 278   host_->event_processor()->GetRootTarget()->AddPreTargetHandler(
 279       user_activity_detector_.get());
 280 #if defined(OS_CHROMEOS)
 281   user_activity_notifier_.reset(
 282       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
 283 #endif
 284 }
 285
 286 void ShellDesktopController::DestroyRootWindow() {
 287   host_->RemoveObserver(this);
 288   if (input_method_filter_)
 289     root_window_event_filter_->RemoveHandler(input_method_filter_.get());
 290   if (user_activity_detector_) {
 291     host_->event_processor()->GetRootTarget()->RemovePreTargetHandler(
 292         user_activity_detector_.get());
 293   }
 294   wm::FocusController* focus_controller =
 295       static_cast<wm::FocusController*>(focus_client_.get());
 296   if (focus_controller) {
 297     host_->window()->RemovePreTargetHandler(focus_controller);
 298     aura::client::SetActivationClient(host_->window(), NULL);
 299   }
 300   root_window_event_filter_.reset();
 301   capture_client_.reset();
 302   input_method_filter_.reset();
 303   focus_client_.reset();
 304   cursor_manager_.reset();
 305 #if defined(OS_CHROMEOS)
 306   user_activity_notifier_.reset();
 307 #endif
 308   user_activity_detector_.reset();
 309   host_.reset();
 310 }
 311
 312 gfx::Size ShellDesktopController::GetPrimaryDisplaySize() {
 313 #if defined(OS_CHROMEOS)
 314   const std::vector<ui::DisplayConfigurator::DisplayState>& displays =
 315       display_configurator_->cached_displays();
 316   if (displays.empty())
 317     return gfx::Size();
 318   const ui::DisplayMode* mode = displays[0].display->current_mode();
 319   return mode ? mode->size() : gfx::Size();
 320 #else
 321   return gfx::Size();
 322 #endif
 323 }
 324
 325 }  // namespace apps