[WIP] ui/window: Master CL.

ui/aura/window_tree_host_x11.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 "ui/aura/window_tree_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 26 matching lines @@
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/events/x/device_data_manager.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/screen.h"
+#include "ui/window/platform_window.h"
 
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
 const char* kAtomsToCache[] = {
   "WM_DELETE_WINDOW",
@@ skipping 111 matching lines @@
                   xwindow_,
                   atom_cache_.GetAtom("_NET_WM_PID"),
                   XA_CARDINAL,
                   32,
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid), 1);
 
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
   CreateCompositor(GetAcceleratedWidget());
+
+  platform_window_ = ui::CreateDefaultPlatformWindow(this);
+  platform_window_->SetBounds(bounds);
 }
 
 WindowTreeHostX11::~WindowTreeHostX11() {
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 
   DestroyCompositor();
   DestroyDispatcher();
   XDestroyWindow(xdisplay_, xwindow_);
 }
@@ skipping 178 matching lines @@
 
     XMapWindow(xdisplay_, xwindow_);
 
     // We now block until our window is mapped. Some X11 APIs will crash and
     // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
     // asynchronous.
     if (ui::X11EventSource::GetInstance())
       ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
     window_mapped_ = true;
   }
+  platform_window_->Show();
 }
 
 void WindowTreeHostX11::Hide() {
+  platform_window_->Hide();
   if (window_mapped_) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
   }
 }
 
 gfx::Rect WindowTreeHostX11::GetBounds() const {
   return bounds_;
 }
 
@@ skipping 28 matching lines @@
   // (possibly synthetic) ConfigureNotify about the actual size and correct
   // |bounds_| later.
   bounds_ = bounds;
   if (origin_changed)
     OnHostMoved(bounds.origin());
   if (size_changed || current_scale != new_scale) {
     OnHostResized(bounds.size());
   } else {
     window()->SchedulePaintInRect(window()->bounds());
   }
+  platform_window_->SetBounds(bounds);
 }
 
 gfx::Point WindowTreeHostX11::GetLocationOnNativeScreen() const {
   return bounds_.origin();
 }
 
 void WindowTreeHostX11::SetCapture() {
   // TODO(oshima): Grab x input.
 }
 
@@ skipping 76 matching lines @@
                bounds_.y() + location.y());
 }
 
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
 }
 
 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
   return dispatcher();
 }
 
+void WindowTreeHostX11::OnBoundsChanged(const gfx::Rect& new_bounds) {
+  bool size_changed = bounds_.size() != new_bounds.size();
+  bool origin_changed = bounds_.origin() != new_bounds.origin();
+  bounds_ = new_bounds;
+  OnConfigureNotify();
+  if (size_changed)
+    OnHostResized(new_bounds.size());
+  if (origin_changed)
+    OnHostMoved(bounds_.origin());
+}
+
+void WindowTreeHostX11::OnDamageRect(const gfx::Rect& damaged_rect) {
+  compositor()->ScheduleRedrawRect(damaged_rect);
+}
+
+void WindowTreeHostX11::DispatchEvent(ui::Event* event) {
+  LOG(ERROR) << "X: " << event->name();
+  if (event->type() == ui::ET_MOUSE_MOVED &&
+      (event->flags() & ui::EF_IS_SYNTHESIZED)) {
+    aura::Window* root_window = window();
+    client::CursorClient* cursor_client = client::GetCursorClient(root_window);
+    if (cursor_client) {
+      const gfx::Display display = gfx::Screen::GetScreenFor(root_window)
+                                       ->GetDisplayNearestWindow(root_window);
+      cursor_client->SetDisplay(display);
+    }
+  }
+}
+
+void WindowTreeHostX11::OnCloseRequest() {
+}
+
+void WindowTreeHostX11::OnClosed() {
+}
+
+void WindowTreeHostX11::OnWindowStateChanged(
+    ui::PlatformWindowState new_state) {
+}
+
+void WindowTreeHostX11::OnLostCapture() {
+  OnHostLostWindowCapture();
+}
+
 void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) {
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   XEvent* xev = event;
   if (!factory->ShouldProcessXI2Event(xev))
     return;
 
   TRACE_EVENT1("input", "WindowTreeHostX11::DispatchXI2Event",
                "event_latency_us",
                (ui::EventTimeForNow() - ui::EventTimeFromNative(event)).
                  InMicroseconds());
@@ skipping 95 matching lines @@
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura