Refactor ShellDesktopController and ShellNativeAppWindow to allow for non-aura implementations.

extensions/shell/browser/shell_desktop_controller_aura.cc

 // Copyright 2014 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 "extensions/shell/browser/shell_desktop_controller.h"
+#include "extensions/shell/browser/shell_desktop_controller_aura.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/shell/browser/shell_app_delegate.h"
 #include "extensions/shell/browser/shell_app_window_client.h"
 #include "extensions/shell/common/switches.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/test/test_screen.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/image_cursors.h"
 #include "ui/base/ime/input_method_initializer.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/cursor_manager.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/input_method_event_filter.h"
 #include "ui/wm/core/native_cursor_manager.h"
 #include "ui/wm/core/native_cursor_manager_delegate.h"
 #include "ui/wm/core/user_activity_detector.h"
@@ skipping 114 matching lines @@
   bool SupportsChildActivation(aura::Window* window) const override {
     return true;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AppsFocusRules);
 };
 
 }  // namespace
 
-ShellDesktopController::ShellDesktopController()
+ShellDesktopControllerAura::ShellDesktopControllerAura()
     : app_window_client_(new ShellAppWindowClient) {
   extensions::AppWindowClient::Set(app_window_client_.get());
 
 #if defined(OS_CHROMEOS)
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      AddObserver(this);
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(
+      this);
   display_configurator_.reset(new ui::DisplayConfigurator);
   display_configurator_->Init(false);
   display_configurator_->ForceInitialConfigure(0);
   display_configurator_->AddObserver(this);
 #endif
   CreateRootWindow();
 }
 
-ShellDesktopController::~ShellDesktopController() {
+ShellDesktopControllerAura::~ShellDesktopControllerAura() {
   CloseAppWindows();
   DestroyRootWindow();
 #if defined(OS_CHROMEOS)
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      RemoveObserver(this);
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
+      this);
 #endif
   extensions::AppWindowClient::Set(NULL);
 }
 
-aura::WindowTreeHost* ShellDesktopController::GetHost() {
-  return host_.get();
+gfx::Size ShellDesktopControllerAura::GetWindowSize() {
+  return host_->window()->bounds().size();
 }
 
-AppWindow* ShellDesktopController::CreateAppWindow(
+AppWindow* ShellDesktopControllerAura::CreateAppWindow(
     content::BrowserContext* context,
     const Extension* extension) {
   app_windows_.push_back(
       new AppWindow(context, new ShellAppDelegate, extension));
   return app_windows_.back();
 }
 
-void ShellDesktopController::AddAppWindow(aura::Window* window) {
-  aura::Window* root_window = GetHost()->window();
+void ShellDesktopControllerAura::AddAppWindow(gfx::NativeWindow window) {
+  aura::Window* root_window = host_->window();
   root_window->AddChild(window);
 }
 
-void ShellDesktopController::RemoveAppWindow(AppWindow* window) {
+void ShellDesktopControllerAura::RemoveAppWindow(AppWindow* window) {
   auto iter = std::find(app_windows_.begin(), app_windows_.end(), window);
   DCHECK(iter != app_windows_.end());
   app_windows_.erase(iter);
 }
 
-void ShellDesktopController::CloseAppWindows() {
+void ShellDesktopControllerAura::CloseAppWindows() {
   // Create a copy of the window vector, because closing the windows will
   // trigger RemoveAppWindow, which will invalidate the iterator.
   // This vector should be small enough that this should not be an issue.
   std::vector<AppWindow*> app_windows(app_windows_);
   for (AppWindow* app_window : app_windows)
     app_window->GetBaseWindow()->Close();  // Close() deletes |app_window|.
   app_windows_.clear();
 }
 
-aura::Window* ShellDesktopController::GetDefaultParent(
+aura::Window* ShellDesktopControllerAura::GetDefaultParent(
     aura::Window* context,
     aura::Window* window,
     const gfx::Rect& bounds) {
   return host_->window();
 }
 
 #if defined(OS_CHROMEOS)
-void ShellDesktopController::PowerButtonEventReceived(
+void ShellDesktopControllerAura::PowerButtonEventReceived(
     bool down,
     const base::TimeTicks& timestamp) {
   if (down) {
-    chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-        RequestShutdown();
+    chromeos::DBusThreadManager::Get()
+        ->GetPowerManagerClient()
+        ->RequestShutdown();
   }
 }
 
-void ShellDesktopController::OnDisplayModeChanged(
+void ShellDesktopControllerAura::OnDisplayModeChanged(
     const std::vector<ui::DisplayConfigurator::DisplayState>& displays) {
   gfx::Size size = GetPrimaryDisplaySize();
   if (!size.IsEmpty())
     host_->UpdateRootWindowSize(size);
 }
 #endif
 
-void ShellDesktopController::OnHostCloseRequested(
+void ShellDesktopControllerAura::OnHostCloseRequested(
     const aura::WindowTreeHost* host) {
   DCHECK_EQ(host_.get(), host);
   CloseAppWindows();
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::MessageLoop::QuitClosure());
 }
 
-void ShellDesktopController::InitWindowManager() {
+void ShellDesktopControllerAura::InitWindowManager() {
   wm::FocusController* focus_controller =
       new wm::FocusController(new AppsFocusRules());
   aura::client::SetFocusClient(host_->window(), focus_controller);
   host_->window()->AddPreTargetHandler(focus_controller);
   aura::client::SetActivationClient(host_->window(), focus_controller);
   focus_client_.reset(focus_controller);
 
   input_method_filter_.reset(
       new wm::InputMethodEventFilter(host_->GetAcceleratedWidget()));
   input_method_filter_->SetInputMethodPropertyInRootWindow(host_->window());
@@ skipping 15 matching lines @@
 
   user_activity_detector_.reset(new wm::UserActivityDetector);
   host_->event_processor()->GetRootTarget()->AddPreTargetHandler(
       user_activity_detector_.get());
 #if defined(OS_CHROMEOS)
   user_activity_notifier_.reset(
       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
 #endif
 }
 
-void ShellDesktopController::CreateRootWindow() {
+void ShellDesktopControllerAura::CreateRootWindow() {
   // Set up basic pieces of ui::wm.
   gfx::Size size;
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kAppShellHostWindowBounds)) {
     const std::string size_str =
         command_line->GetSwitchValueASCII(switches::kAppShellHostWindowBounds);
     int width, height;
     CHECK_EQ(2, sscanf(size_str.c_str(), "%dx%d", &width, &height));
     size = gfx::Size(width, height);
   } else {
@@ skipping 13 matching lines @@
   root_window_event_filter_.reset(new wm::CompoundEventFilter);
   host_->window()->AddPreTargetHandler(root_window_event_filter_.get());
   InitWindowManager();
 
   host_->AddObserver(this);
 
   // Ensure the X window gets mapped.
   host_->Show();
 }
 
-void ShellDesktopController::DestroyRootWindow() {
+void ShellDesktopControllerAura::DestroyRootWindow() {
   host_->RemoveObserver(this);
   if (input_method_filter_)
     root_window_event_filter_->RemoveHandler(input_method_filter_.get());
   if (user_activity_detector_) {
     host_->event_processor()->GetRootTarget()->RemovePreTargetHandler(
         user_activity_detector_.get());
   }
   wm::FocusController* focus_controller =
       static_cast<wm::FocusController*>(focus_client_.get());
   if (focus_controller) {
     host_->window()->RemovePreTargetHandler(focus_controller);
     aura::client::SetActivationClient(host_->window(), NULL);
   }
   root_window_event_filter_.reset();
   capture_client_.reset();
   input_method_filter_.reset();
   focus_client_.reset();
   cursor_manager_.reset();
 #if defined(OS_CHROMEOS)
   user_activity_notifier_.reset();
 #endif
   user_activity_detector_.reset();
   host_.reset();
 }
 
-gfx::Size ShellDesktopController::GetPrimaryDisplaySize() {
+gfx::Size ShellDesktopControllerAura::GetPrimaryDisplaySize() {
 #if defined(OS_CHROMEOS)
   const std::vector<ui::DisplayConfigurator::DisplayState>& displays =
       display_configurator_->cached_displays();
   if (displays.empty())
     return gfx::Size();
   const ui::DisplayMode* mode = displays[0].display->current_mode();
   return mode ? mode->size() : gfx::Size();
 #else
   return gfx::Size();
 #endif
 }
 
 }  // namespace extensions