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