Implement cursor compositing mode on Ash

ash/display/display_controller.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/display/display_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 
 #include "ash/ash_switches.h"
+#include "ash/display/cursor_window_controller.h"
 #include "ash/display/display_layout_store.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/mirror_window_controller.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/display/virtual_keyboard_window_controller.h"
 #include "ash/host/root_window_host_factory.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
+#include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/root_window_transformer.h"
 #include "ui/aura/window.h"
@@ skipping 175 matching lines @@
 
 bool DisplayController::DisplayChangeLimiter::IsThrottled() const {
   return base::Time::Now() < throttle_timeout_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DisplayController
 
 DisplayController::DisplayController()
     : primary_root_window_for_replace_(NULL),
+      is_cursor_compositing_enabled_(false),
       focus_activation_store_(new internal::FocusActivationStore()),
-      mirror_window_controller_(new internal::MirrorWindowController),
+      cursor_window_controller_(new internal::CursorWindowController()),
+      mirror_window_controller_(new internal::MirrorWindowController(
+              cursor_window_controller_.get())),
       virtual_keyboard_window_controller_(
           new internal::VirtualKeyboardWindowController) {
 #if defined(OS_CHROMEOS)
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kAshDisableDisplayChangeLimiter) &&
       base::SysInfo::IsRunningOnChromeOS())
     limiter_.reset(new DisplayChangeLimiter);
 #endif
   // Reset primary display to make sure that tests don't use
   // stale display info from previous tests.
@@ skipping 13 matching lines @@
     FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanged());
   }
 }
 
 void DisplayController::Shutdown() {
   // Unset the display manager's delegate here because
   // DisplayManager outlives DisplayController.
   Shell::GetInstance()->display_manager()->set_delegate(NULL);
 
   mirror_window_controller_.reset();
+  cursor_window_controller_.reset();
   virtual_keyboard_window_controller_.reset();
 
   Shell::GetScreen()->RemoveObserver(this);
   // Delete all root window controllers, which deletes root window
   // from the last so that the primary root window gets deleted last.
   for (std::map<int64, aura::Window*>::const_reverse_iterator it =
            root_windows_.rbegin(); it != root_windows_.rend(); ++it) {
     internal::RootWindowController* controller =
         internal::GetRootWindowController(it->second);
     DCHECK(controller);
@@ skipping 130 matching lines @@
           base::Unretained(this)));
     } else {
       SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
     }
 #else
     SetPrimaryDisplay(ScreenUtil::GetSecondaryDisplay());
 #endif
   }
 }
 
+void DisplayController::SetCursorCompositingEnabled(bool enabled) {
+#if defined(OS_CHROMEOS) && defined(USE_X11)
+  if (is_cursor_compositing_enabled_ != enabled) {
+    is_cursor_compositing_enabled_ = enabled;
+    UpdateCursorWindowContainer();
+  }
+#endif
+}
+
+void DisplayController::SetDisplayForCursor(const gfx::Display& display) {
+  if (!is_cursor_compositing_enabled_)
+    return;
+
+  cursor_window_controller_->SetContainer(
+      internal::GetRootWindowController(root_windows_[display.id()])->
+      GetContainer(internal::kShellWindowId_OverlayContainer));
+  cursor_window_controller_->SetDisplayBounds(display.bounds());
+}
+
 void DisplayController::SetPrimaryDisplayId(int64 id) {
   DCHECK_NE(gfx::Display::kInvalidDisplayID, id);
   if (id == gfx::Display::kInvalidDisplayID || primary_display_id == id)
     return;
 
   const gfx::Display& display = GetDisplayManager()->GetDisplayForId(id);
   if (display.is_valid())
     SetPrimaryDisplay(display);
 }
 
@@ skipping 193 matching lines @@
 
 void DisplayController::OnWindowTreeHostResized(const aura::RootWindow* root) {
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
       const_cast<aura::Window*>(root->window()));
 
   internal::DisplayManager* display_manager = GetDisplayManager();
   if (display_manager->UpdateDisplayBounds(
           display.id(),
           root->host()->GetBounds())) {
     mirror_window_controller_->UpdateWindow();
+    UpdateCursorWindowContainer();
   }
 }
 
 void DisplayController::CreateOrUpdateNonDesktopDisplay(
     const internal::DisplayInfo& info) {
   switch (GetDisplayManager()->second_display_mode()) {
     case internal::DisplayManager::MIRRORING:
       mirror_window_controller_->UpdateWindow(info);
       virtual_keyboard_window_controller_->Close();
+      UpdateCursorWindowContainer();
       break;
     case internal::DisplayManager::VIRTUAL_KEYBOARD:
       mirror_window_controller_->Close();
       virtual_keyboard_window_controller_->UpdateWindow(info);
+      UpdateCursorWindowContainer();
       break;
     case internal::DisplayManager::EXTENDED:
       NOTREACHED();
   }
 }
 
 void DisplayController::CloseNonDesktopDisplay() {
   mirror_window_controller_->Close();
   virtual_keyboard_window_controller_->Close();
+  UpdateCursorWindowContainer();
 }
 
 void DisplayController::PreDisplayConfigurationChange(bool clear_focus) {
   FOR_EACH_OBSERVER(Observer, observers_, OnDisplayConfigurationChanging());
   focus_activation_store_->Store(clear_focus);
   gfx::Screen* screen = Shell::GetScreen();
   gfx::Point point_in_screen = screen->GetCursorScreenPoint();
   gfx::Display display = screen->GetDisplayNearestPoint(point_in_screen);
   aura::Window* root_window = GetRootWindowForDisplayId(display.id());
 
@@ skipping 86 matching lines @@
   for (size_t i = 0; i < root_windows.size(); ++i) {
     std::string name =
         root_windows[i] == primary ? "aura_root_0" : "aura_root_x";
     gfx::AcceleratedWidget xwindow =
         root_windows[i]->GetDispatcher()->host()->GetAcceleratedWidget();
     XStoreName(gfx::GetXDisplay(), xwindow, name.c_str());
   }
 #endif
 }
 
+void DisplayController::UpdateCursorWindowContainer() {
+#if defined(OS_CHROMEOS) && defined(USE_X11)
+  if (is_cursor_compositing_enabled_) {
+    cursor_window_controller_->SetMirroring(false);
+    cursor_window_controller_->SetContainer(
+        Shell::GetPrimaryRootWindowController()->GetContainer(
+            internal::kShellWindowId_OverlayContainer));
+  } else {
+    aura::RootWindow* mirror_root_window =
+        mirror_window_controller_->root_window();
+    if (mirror_root_window) {
+      cursor_window_controller_->SetMirroring(true);
+      cursor_window_controller_->SetContainer(mirror_root_window->window());
+    } else {
+      cursor_window_controller_->SetContainer(NULL);
+    }
+  }
+#endif
+}
+
 }  // namespace ash