ozone: Add OzoneWindowFactory & OzoneWindow

ui/aura/window_tree_host_ozone.cc

 // Copyright 2013 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_ozone.h"
 
 #include "ui/aura/window_event_dispatcher.h"
-#include "ui/base/cursor/ozone/cursor_factory_ozone.h"
-#include "ui/events/ozone/event_factory_ozone.h"
-#include "ui/gfx/ozone/surface_factory_ozone.h"
 #include "ui/ozone/ozone_platform.h"
+#include "ui/ozone/window/ozone_window.h"
+#include "ui/ozone/window/window_factory_ozone.h"
 
 namespace aura {
 
-WindowTreeHostOzone::WindowTreeHostOzone(const gfx::Rect& bounds)
-    : widget_(0),
-      bounds_(bounds) {
-  ui::OzonePlatform::Initialize();
-
-  // EventFactoryOzone creates converters that obtain input events from the
-  // underlying input system and dispatch them as |ui::Event| instances into
-  // Aura.
+WindowTreeHostOzone::WindowTreeHostOzone(
+    scoped_ptr<ui::OzoneWindow> ozone_window)
+    : ozone_window_(ozone_window.Pass()) {
+  // TODO(spang): Don't use EventFactoryOzone here. We should do
+  // something like: window_->AddPlatformEventDispatcherHandlerController(this);
   ui::EventFactoryOzone::GetInstance()->StartProcessingEvents();
 
-  gfx::SurfaceFactoryOzone* surface_factory =
-      gfx::SurfaceFactoryOzone::GetInstance();
-  widget_ = surface_factory->GetAcceleratedWidget();
-
   base::MessagePumpOzone::Current()->AddDispatcherForRootWindow(this);
   CreateCompositor(GetAcceleratedWidget());
 }
 
 WindowTreeHostOzone::~WindowTreeHostOzone() {
   base::MessagePumpOzone::Current()->RemoveDispatcherForRootWindow(0);
   DestroyCompositor();
   DestroyDispatcher();
 }
 
 uint32_t WindowTreeHostOzone::Dispatch(const base::NativeEvent& ne) {
   ui::Event* event = static_cast<ui::Event*>(ne);
   ui::EventDispatchDetails details ALLOW_UNUSED = SendEventToProcessor(event);
   return POST_DISPATCH_NONE;
 }
 
 gfx::AcceleratedWidget WindowTreeHostOzone::GetAcceleratedWidget() {
-  return widget_;
+  return ozone_window_->GetAcceleratedWidget();
 }
 
 void WindowTreeHostOzone::Show() { NOTIMPLEMENTED(); }
 
 void WindowTreeHostOzone::Hide() { NOTIMPLEMENTED(); }
 
 void WindowTreeHostOzone::ToggleFullScreen() { NOTIMPLEMENTED(); }
 
-gfx::Rect WindowTreeHostOzone::GetBounds() const { return bounds_; }
+gfx::Rect WindowTreeHostOzone::GetBounds() const {
+  return ozone_window_->GetBounds();
+}
 
 void WindowTreeHostOzone::SetBounds(const gfx::Rect& bounds) {
   NOTIMPLEMENTED();
 }
 
 gfx::Insets WindowTreeHostOzone::GetInsets() const { return gfx::Insets(); }
 
 void WindowTreeHostOzone::SetInsets(const gfx::Insets& insets) {
   NOTIMPLEMENTED();
 }
 
 gfx::Point WindowTreeHostOzone::GetLocationOnNativeScreen() const {
-  return bounds_.origin();
+  return gfx::Point();
 }
 
 void WindowTreeHostOzone::SetCapture() { NOTIMPLEMENTED(); }
 
 void WindowTreeHostOzone::ReleaseCapture() { NOTIMPLEMENTED(); }
 
 bool WindowTreeHostOzone::QueryMouseLocation(gfx::Point* location_return) {
   NOTIMPLEMENTED();
   return false;
 }
@@ skipping 11 matching lines @@
 }
 
 void WindowTreeHostOzone::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   NOTIMPLEMENTED();
 }
 
 void WindowTreeHostOzone::PrepareForShutdown() { NOTIMPLEMENTED(); }
 
 void WindowTreeHostOzone::SetCursorNative(gfx::NativeCursor cursor) {
-  ui::CursorFactoryOzone::GetInstance()->SetCursor(GetAcceleratedWidget(),
-                                                   cursor.platform());
+  ozone_window_->SetCursor(cursor.platform());
 }
 
 void WindowTreeHostOzone::MoveCursorToNative(const gfx::Point& location) {
-  ui::EventFactoryOzone::GetInstance()->WarpCursorTo(GetAcceleratedWidget(),
-                                                     location);
+  ozone_window_->WarpCursorTo(location);
 }
 
 void WindowTreeHostOzone::OnCursorVisibilityChangedNative(bool show) {
   NOTIMPLEMENTED();
 }
 
 ui::EventProcessor* WindowTreeHostOzone::GetEventProcessor() {
   return dispatcher();
 }
 
 // static
 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
-  return new WindowTreeHostOzone(bounds);
+  ui::OzonePlatform::Initialize();
+  scoped_ptr<ui::OzoneWindow> ozone_window =
+      ui::WindowFactoryOzone::GetInstance()->CreateWindow(bounds);
+  return new WindowTreeHostOzone(ozone_window.Pass());
 }
 
 // static
 gfx::Size WindowTreeHost::GetNativeScreenSize() {
   NOTIMPLEMENTED();
   return gfx::Size();
 }
 
 }  // namespace aura