[PATCH] WIP: Chromium: failed attempt to DRWHWayland derive DesktopRootWindowHostOzone

gistfile1.txt

From fa33786ca0fd9a30b650b171f6f50b3888f8608c Mon Sep 17 00:00:00 2001
From: Tiago Vignatti <tiago.vignatti@intel.com>
Date: Fri, 22 Nov 2013 11:36:33 -0200
Subject: [PATCH] WIP: Chromium: failed attempt to DRWHWayland derive
 DesktopRootWindowHostOzone

---
 .../browser_desktop_root_window_host_ozone.cc      |   16 +-
 .../frame/browser_desktop_root_window_host_ozone.h |    9 +-
 ui/views/views.gyp                                 |    1 +
 .../desktop_aura/desktop_root_window_host_ozone.cc |  320 +++++++++++++++++++-
 .../desktop_aura/desktop_root_window_host_ozone.h  |  125 ++++++++
 5 files changed, 454 insertions(+), 17 deletions(-)
 create mode 100644 ui/views/widget/desktop_aura/desktop_root_window_host_ozone.h

diff --git a/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.cc b/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.cc
index dc4a06d..7b92677 100644
--- a/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.cc
+++ b/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.cc
@@ -11,15 +11,12 @@ BrowserDesktopRootWindowHostOzone::BrowserDesktopRootWindowHostOzone(
     views::internal::NativeWidgetDelegate* native_widget_delegate,
     views::DesktopNativeWidgetAura* desktop_native_widget_aura,
     BrowserView* browser_view)
-      : browser_view_(browser_view),
-      desktop_root_window_host_(NULL) {
-  desktop_root_window_host_ = views::DesktopRootWindowHost::Create(
-      native_widget_delegate,
-      desktop_native_widget_aura);
+      : DesktopRootWindowHostOzone(native_widget_delegate,
+                                   desktop_native_widget_aura),
+      browser_view_(browser_view) {
 }
 
 BrowserDesktopRootWindowHostOzone::~BrowserDesktopRootWindowHostOzone() {
-  desktop_root_window_host_ = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -28,7 +25,7 @@ BrowserDesktopRootWindowHostOzone::~BrowserDesktopRootWindowHostOzone() {
 
 views::DesktopRootWindowHost*
     BrowserDesktopRootWindowHostOzone::AsDesktopRootWindowHost() {
-  return desktop_root_window_host_;
+  return this;
 }
 
 int BrowserDesktopRootWindowHostOzone::GetMinimizeButtonOffset() const {
@@ -47,11 +44,12 @@ void BrowserDesktopRootWindowHostOzone::Init(
     aura::Window* content_window,
     const views::Widget::InitParams& params,
     aura::RootWindow::CreateParams* rw_create_params) {
-  desktop_root_window_host_->Init(content_window, params, rw_create_params);
+  views::DesktopRootWindowHostOzone::Init(content_window, params,
+                                          rw_create_params);
 }
 
 void BrowserDesktopRootWindowHostOzone::CloseNow() {
-  desktop_root_window_host_->CloseNow();
+  DesktopRootWindowHostOzone::CloseNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.h b/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.h
index cb79cda..fec83c1 100644
--- a/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.h
+++ b/chrome/browser/ui/views/frame/browser_desktop_root_window_host_ozone.h
@@ -5,8 +5,7 @@
 #ifndef CHROME_BROWSER_UI_VIEWS_FRAME_BROWSER_DESKTOP_ROOT_WINDOW_HOST_OZONE_H_
 #define CHROME_BROWSER_UI_VIEWS_FRAME_BROWSER_DESKTOP_ROOT_WINDOW_HOST_OZONE_H_
 
-#include "ui/aura/window_tree_host.h"
-#include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
+#include "ui/views/widget/desktop_aura/desktop_root_window_host_ozone.h"
 #include "chrome/browser/ui/views/frame/browser_desktop_root_window_host.h"
 
 class BrowserFrame;
@@ -17,7 +16,8 @@ class DesktopNativeWidgetAura;
 }
 
 class BrowserDesktopRootWindowHostOzone
-    : public BrowserDesktopRootWindowHost {
+    : public BrowserDesktopRootWindowHost,
+      public views::DesktopRootWindowHostOzone {
  public:
   BrowserDesktopRootWindowHostOzone(
       views::internal::NativeWidgetDelegate* native_widget_delegate,
@@ -40,9 +40,6 @@ class BrowserDesktopRootWindowHostOzone
 
   BrowserView* browser_view_;
 
-  // Ownership passed to RootWindow on Init.
-  views::DesktopRootWindowHost* desktop_root_window_host_;
-
   DISALLOW_COPY_AND_ASSIGN(BrowserDesktopRootWindowHostOzone);
 };
 
diff --git a/ui/views/views.gyp b/ui/views/views.gyp
index 80e50c3..63100d5 100644
--- a/ui/views/views.gyp
+++ b/ui/views/views.gyp
@@ -389,6 +389,7 @@
         'widget/desktop_aura/desktop_native_widget_aura.h',
         'widget/desktop_aura/desktop_root_window_host.h',
         'widget/desktop_aura/desktop_root_window_host_ozone.cc',
+        'widget/desktop_aura/desktop_root_window_host_ozone.h',
         'widget/desktop_aura/desktop_root_window_host_win.cc',
         'widget/desktop_aura/desktop_root_window_host_win.h',
         'widget/desktop_aura/desktop_root_window_host_x11.cc',
diff --git a/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.cc b/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.cc
index ffca2a6..5616154 100644
--- a/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.cc
+++ b/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.cc
@@ -2,19 +2,335 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "ui/views/widget/desktop_aura/desktop_root_window_host_ozone.h"
+
 #include "ui/aura/window_tree_host.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
 #include "ui/views/widget/desktop_aura/desktop_factory_ozone.h"
 
 namespace views {
 
+DesktopRootWindowHost* drwh_ozone_;
+
+////////////////////////////////////////////////////////////////////////////////
+// DesktopRootWindowHostOzone, public:
+DesktopRootWindowHostOzone::DesktopRootWindowHostOzone(
+    internal::NativeWidgetDelegate* native_widget_delegate,
+    DesktopNativeWidgetAura* desktop_native_widget_aura) {
+}
+
+DesktopRootWindowHostOzone::~DesktopRootWindowHostOzone() {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DesktopRootWindowHostOzone, DesktopRootWindowHost implementation:
+
+void DesktopRootWindowHostOzone::Init(
+    aura::Window* content_window,
+    const Widget::InitParams& params,
+    aura::RootWindow::CreateParams* rw_create_params) {
+  drwh_ozone_->Init(content_window, params, rw_create_params);
+}
+
+#if 0
+
+void DesktopRootWindowHostOzone::OnRootWindowCreated(
+    aura::RootWindow* root,
+    const Widget::InitParams& params) {
+}
+
+scoped_ptr<corewm::Tooltip> DesktopRootWindowHostX11::CreateTooltip() {
+  return scoped_ptr<corewm::Tooltip>(
+      new corewm::TooltipAura(gfx::SCREEN_TYPE_NATIVE));
+}
+
+scoped_ptr<aura::client::DragDropClient>
+DesktopRootWindowHostX11::CreateDragDropClient(
+    DesktopNativeCursorManager* cursor_manager) {
+  drag_drop_client_ = new DesktopDragDropClientAuraX11(
+      root_window_->window(), cursor_manager, xdisplay_, xwindow_);
+  return scoped_ptr<aura::client::DragDropClient>(drag_drop_client_).Pass();
+}
+
+void DesktopRootWindowHostX11::Close() {
+}
+
+void DesktopRootWindowHostOzone::CloseNow() {
+  drwh_ozone_->CloseNow();
+}
+
+aura::RootWindowHost* DesktopRootWindowHostX11::AsRootWindowHost() {
+  return this;
+}
+
+void DesktopRootWindowHostX11::ShowWindowWithState(
+    ui::WindowShowState show_state) {
+  if (show_state != ui::SHOW_STATE_DEFAULT &&
+      show_state != ui::SHOW_STATE_NORMAL) {
+    // Only forwarding to Show().
+    NOTIMPLEMENTED();
+  }
+
+  Show();
+}
+
+void DesktopRootWindowHostX11::ShowMaximizedWithBounds(
+    const gfx::Rect& restored_bounds) {
+  restored_bounds_ = restored_bounds;
+  Maximize();
+  Show();
+}
+
+bool DesktopRootWindowHostX11::IsVisible() const {
+  return window_mapped_;
+}
+
+void DesktopRootWindowHostX11::SetSize(const gfx::Size& size) {
+  // TODO(erg):
+  NOTIMPLEMENTED();
+}
+
+void DesktopRootWindowHostX11::CenterWindow(const gfx::Size& size) {
+}
+
+void DesktopRootWindowHostX11::GetWindowPlacement(
+    gfx::Rect* bounds,
+    ui::WindowShowState* show_state) const {
+}
+
+gfx::Rect DesktopRootWindowHostX11::GetWindowBoundsInScreen() const {
+  return bounds_;
+}
+
+gfx::Rect DesktopRootWindowHostX11::GetClientAreaBoundsInScreen() const {
+  // TODO(erg): The NativeWidgetAura version returns |bounds_|, claiming its
+  // needed for View::ConvertPointToScreen() to work
+  // correctly. DesktopRootWindowHostWin::GetClientAreaBoundsInScreen() just
+  // asks windows what it thinks the client rect is.
+  //
+  // Attempts to calculate the rect by asking the NonClientFrameView what it
+  // thought its GetBoundsForClientView() were broke combobox drop down
+  // placement.
+  return bounds_;
+}
+
+gfx::Rect DesktopRootWindowHostX11::GetRestoredBounds() const {
+  // We can't reliably track the restored bounds of a window, but we can get
+  // the 90% case down. When *chrome* is the process that requests maximizing
+  // or restoring bounds, we can record the current bounds before we request
+  // maximization, and clear it when we detect a state change.
+  if (!restored_bounds_.IsEmpty())
+    return restored_bounds_;
+
+  return GetWindowBoundsInScreen();
+}
+
+gfx::Rect DesktopRootWindowHostX11::GetWorkAreaBoundsInScreen() const {
+
+}
+
+void DesktopRootWindowHostX11::SetShape(gfx::NativeRegion native_region) {
+}
+
+void DesktopRootWindowHostX11::Activate() {
+  X11DesktopHandler::get()->ActivateWindow(xwindow_);
+}
+
+void DesktopRootWindowHostX11::Deactivate() {
+  // Deactivating a window means activating nothing.
+  X11DesktopHandler::get()->ActivateWindow(None);
+}
+
+bool DesktopRootWindowHostX11::IsActive() const {
+  return X11DesktopHandler::get()->IsActiveWindow(xwindow_);
+}
+
+void DesktopRootWindowHostX11::Maximize() {
+}
+
+void DesktopRootWindowHostX11::Minimize() {
+  XIconifyWindow(xdisplay_, xwindow_, 0);
+}
+
+void DesktopRootWindowHostX11::Restore() {
+  SetWMSpecState(false,
+                 atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
+                 atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
+}
+
+bool DesktopRootWindowHostX11::IsMaximized() const {
+  return (HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_VERT") ||
+          HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_HORZ"));
+}
+
+bool DesktopRootWindowHostX11::IsMinimized() const {
+  return HasWMSpecProperty("_NET_WM_STATE_HIDDEN");
+}
+
+
+bool DesktopRootWindowHostX11::HasCapture() const {
+  return g_current_capture == this;
+}
+
+
+void DesktopRootWindowHostX11::SetAlwaysOnTop(bool always_on_top) {
+  is_always_on_top_ = always_on_top;
+  SetWMSpecState(always_on_top,
+                 atom_cache_.GetAtom("_NET_WM_STATE_ABOVE"),
+                 None);
+}
+
+bool DesktopRootWindowHostX11::IsAlwaysOnTop() const {
+  return is_always_on_top_;
+}
+
+void DesktopRootWindowHostX11::SetWindowTitle(const string16& title) {
+}
+
+void DesktopRootWindowHostX11::ClearNativeFocus() {
+}
+
+Widget::MoveLoopResult DesktopRootWindowHostX11::RunMoveLoop(
+    const gfx::Vector2d& drag_offset,
+    Widget::MoveLoopSource source,
+    Widget::MoveLoopEscapeBehavior escape_behavior) {
+}
+
+void DesktopRootWindowHostX11::EndMoveLoop() {
+  x11_window_move_client_->EndMoveLoop();
+}
+
+void DesktopRootWindowHostX11::SetVisibilityChangedAnimationsEnabled(
+    bool value) {
+  // Much like the previous NativeWidgetGtk, we don't have anything to do here.
+}
+
+bool DesktopRootWindowHostX11::ShouldUseNativeFrame() {
+  return false;
+}
+
+void DesktopRootWindowHostX11::FrameTypeChanged() {
+  // Replace the frame and layout the contents. Even though we don't have a
+  // swapable glass frame like on Windows, we still replace the frame because
+  // the button assets don't update otherwise.
+  native_widget_delegate_->AsWidget()->non_client_view()->UpdateFrame(true);
+}
+
+NonClientFrameView* DesktopRootWindowHostX11::CreateNonClientFrameView() {
+  return NULL;
+}
+
+void DesktopRootWindowHostX11::SetFullscreen(bool fullscreen) {
+  is_fullscreen_ = fullscreen;
+  SetWMSpecState(fullscreen,
+                 atom_cache_.GetAtom("_NET_WM_STATE_FULLSCREEN"),
+                 None);
+}
+
+bool DesktopRootWindowHostX11::IsFullscreen() const {
+  return is_fullscreen_;
+}
+
+void DesktopRootWindowHostX11::SetOpacity(unsigned char opacity) {
+  // X server opacity is in terms of 32 bit unsigned int space, and counts from
+  // the opposite direction.
+  // XChangeProperty() expects "cardinality" to be long.
+  unsigned long cardinality = opacity * 0x1010101;
+
+  if (cardinality == 0xffffffff) {
+    XDeleteProperty(xdisplay_, xwindow_,
+                    atom_cache_.GetAtom("_NET_WM_WINDOW_OPACITY"));
+  } else {
+    XChangeProperty(xdisplay_, xwindow_,
+                    atom_cache_.GetAtom("_NET_WM_WINDOW_OPACITY"),
+                    XA_CARDINAL, 32,
+                    PropModeReplace,
+                    reinterpret_cast<unsigned char*>(&cardinality), 1);
+  }
+}
+
+void DesktopRootWindowHostX11::SetWindowIcons(
+}
+
+void DesktopRootWindowHostX11::InitModalType(ui::ModalType modal_type) {
+}
+
+void DesktopRootWindowHostX11::FlashFrame(bool flash_frame) {
+}
+
+void DesktopRootWindowHostX11::OnRootViewLayout() const {
+}
+
+void DesktopRootWindowHostX11::OnNativeWidgetFocus() {
+  native_widget_delegate_->AsWidget()->GetInputMethod()->OnFocus();
+}
+
+void DesktopRootWindowHostX11::OnNativeWidgetBlur() {
+  if (xwindow_)
+    native_widget_delegate_->AsWidget()->GetInputMethod()->OnBlur();
+}
+
+bool DesktopRootWindowHostX11::IsAnimatingClosed() const {
+  return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// DesktopRootWindowHostOzone, aura::RootWindowHost implementation:
+
+
+aura::RootWindow* DesktopRootWindowHostX11::GetRootWindow() {
+  return root_window_;
+}
+
+gfx::AcceleratedWidget DesktopRootWindowHostX11::GetAcceleratedWidget() {
+  return xwindow_;
+}
+
+void DesktopRootWindowHostX11::Show() {
+}
+
+void DesktopRootWindowHostX11::Hide() {
+  if (window_mapped_) {
+    XWithdrawWindow(xdisplay_, xwindow_, 0);
+    window_mapped_ = false;
+  }
+}
+
+void DesktopRootWindowHostX11::ToggleFullScreen() {
+  NOTIMPLEMENTED();
+}
+
+gfx::Rect DesktopRootWindowHostX11::GetBounds() const {
+  return bounds_;
+}
+
+void DesktopRootWindowHostX11::SetBounds(const gfx::Rect& bounds) {
+}
+
+gfx::Insets DesktopRootWindowHostX11::GetInsets() const {
+  return gfx::Insets();
+}
+
+void DesktopRootWindowHostX11::SetInsets(const gfx::Insets& insets) {
+}
+
+gfx::Point DesktopRootWindowHostX11::GetLocationOnNativeScreen() const {
+  return bounds_.origin();
+}
+
+#endif
+
 DesktopRootWindowHost* DesktopRootWindowHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   DesktopFactoryOzone* d_factory = DesktopFactoryOzone::GetInstance();
 
-  return d_factory->CreateRootWindowHost(native_widget_delegate,
-                                         desktop_native_widget_aura);
+  drwh_ozone_ = d_factory->CreateRootWindowHost(
+      native_widget_delegate,
+      desktop_native_widget_aura);
+
+  return drwh_ozone_;  
 }
 
 }  // namespace views
diff --git a/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.h b/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.h
new file mode 100644
index 0000000..2d7f04c
--- /dev/null
+++ b/ui/views/widget/desktop_aura/desktop_root_window_host_ozone.h
@@ -0,0 +1,125 @@
+// Copyright (c) 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.
+
+#ifndef UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_OZONE_H_
+#define UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_OZONE_H_
+
+#include "base/basictypes.h"
+#include "base/memory/weak_ptr.h"
+#include "ui/aura/window_tree_host.h"
+#include "ui/gfx/rect.h"
+#include "ui/views/views_export.h"
+#include "ui/views/widget/desktop_aura/desktop_root_window_host.h"
+
+namespace gfx {
+class ImageSkia;
+class ImageSkiaRep;
+}
+
+namespace views {
+
+class VIEWS_EXPORT DesktopRootWindowHostOzone :
+    public DesktopRootWindowHost,
+    public aura::RootWindowHost,
+    public base::MessageLoop::Dispatcher {
+ public:
+  DesktopRootWindowHostOzone(
+      internal::NativeWidgetDelegate* native_widget_delegate,
+      DesktopNativeWidgetAura* desktop_native_widget_aura);
+  virtual ~DesktopRootWindowHostOzone();
+
+ protected:
+  // Overridden from DesktopRootWindowHost:
+  virtual void Init(aura::Window* content_window,
+                    const Widget::InitParams& params,
+                    aura::RootWindow::CreateParams* rw_create_params) OVERRIDE;
+  virtual void OnRootWindowCreated(aura::RootWindow* root,
+                                   const Widget::InitParams& params) OVERRIDE;
+  virtual scoped_ptr<corewm::Tooltip> CreateTooltip() OVERRIDE;
+  virtual scoped_ptr<aura::client::DragDropClient>
+      CreateDragDropClient(DesktopNativeCursorManager* cursor_manager) OVERRIDE;
+  virtual void Close() OVERRIDE;
+  virtual void CloseNow() OVERRIDE;
+  virtual aura::RootWindowHost* AsRootWindowHost() OVERRIDE;
+  virtual void ShowWindowWithState(ui::WindowShowState show_state) OVERRIDE;
+  virtual void ShowMaximizedWithBounds(
+      const gfx::Rect& restored_bounds) OVERRIDE;
+  virtual bool IsVisible() const OVERRIDE;
+  virtual void SetSize(const gfx::Size& size) OVERRIDE;
+  virtual void CenterWindow(const gfx::Size& size) OVERRIDE;
+  virtual void GetWindowPlacement(
+      gfx::Rect* bounds,
+      ui::WindowShowState* show_state) const OVERRIDE;
+  virtual gfx::Rect GetWindowBoundsInScreen() const OVERRIDE;
+  virtual gfx::Rect GetClientAreaBoundsInScreen() const OVERRIDE;
+  virtual gfx::Rect GetRestoredBounds() const OVERRIDE;
+  virtual gfx::Rect GetWorkAreaBoundsInScreen() const OVERRIDE;
+  virtual void SetShape(gfx::NativeRegion native_region) OVERRIDE;
+  virtual void Activate() OVERRIDE;
+  virtual void Deactivate() OVERRIDE;
+  virtual bool IsActive() const OVERRIDE;
+  virtual void Maximize() OVERRIDE;
+  virtual void Minimize() OVERRIDE;
+  virtual void Restore() OVERRIDE;
+  virtual bool IsMaximized() const OVERRIDE;
+  virtual bool IsMinimized() const OVERRIDE;
+  virtual bool HasCapture() const OVERRIDE;
+  virtual void SetAlwaysOnTop(bool always_on_top) OVERRIDE;
+  virtual bool IsAlwaysOnTop() const OVERRIDE;
+  virtual void SetWindowTitle(const string16& title) OVERRIDE;
+  virtual void ClearNativeFocus() OVERRIDE;
+  virtual Widget::MoveLoopResult RunMoveLoop(
+      const gfx::Vector2d& drag_offset,
+      Widget::MoveLoopSource source,
+      Widget::MoveLoopEscapeBehavior escape_behavior) OVERRIDE;
+  virtual void EndMoveLoop() OVERRIDE;
+  virtual void SetVisibilityChangedAnimationsEnabled(bool value) OVERRIDE;
+  virtual bool ShouldUseNativeFrame() OVERRIDE;
+  virtual void FrameTypeChanged() OVERRIDE;
+  virtual NonClientFrameView* CreateNonClientFrameView() OVERRIDE;
+  virtual void SetFullscreen(bool fullscreen) OVERRIDE;
+  virtual bool IsFullscreen() const OVERRIDE;
+  virtual void SetOpacity(unsigned char opacity) OVERRIDE;
+  virtual void SetWindowIcons(const gfx::ImageSkia& window_icon,
+                              const gfx::ImageSkia& app_icon) OVERRIDE;
+  virtual void InitModalType(ui::ModalType modal_type) OVERRIDE;
+  virtual void FlashFrame(bool flash_frame) OVERRIDE;
+  virtual void OnRootViewLayout() const OVERRIDE;
+  virtual void OnNativeWidgetFocus() OVERRIDE;
+  virtual void OnNativeWidgetBlur() OVERRIDE;
+  virtual bool IsAnimatingClosed() const OVERRIDE;
+
+  // Overridden from aura::RootWindowHost:
+  virtual aura::RootWindow* GetRootWindow() OVERRIDE;
+  virtual gfx::AcceleratedWidget GetAcceleratedWidget() OVERRIDE;
+  virtual void Show() OVERRIDE;
+  virtual void Hide() OVERRIDE;
+  virtual void ToggleFullScreen() OVERRIDE;
+  virtual gfx::Rect GetBounds() const OVERRIDE;
+  virtual void SetBounds(const gfx::Rect& bounds) OVERRIDE;
+  virtual gfx::Insets GetInsets() const OVERRIDE;
+  virtual void SetInsets(const gfx::Insets& insets) OVERRIDE;
+  virtual gfx::Point GetLocationOnNativeScreen() const OVERRIDE;
+  virtual void SetCapture() OVERRIDE;
+  virtual void ReleaseCapture() OVERRIDE;
+  virtual void SetCursor(gfx::NativeCursor cursor) OVERRIDE;
+  virtual bool QueryMouseLocation(gfx::Point* location_return) OVERRIDE;
+  virtual bool ConfineCursorToRootWindow() OVERRIDE;
+  virtual void UnConfineCursor() OVERRIDE;
+  virtual void OnCursorVisibilityChanged(bool show) OVERRIDE;
+  virtual void MoveCursorTo(const gfx::Point& location) OVERRIDE;
+  virtual void PostNativeEvent(const base::NativeEvent& native_event) OVERRIDE;
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
+  virtual void PrepareForShutdown() OVERRIDE;
+
+private:
+  // Overridden from Dispatcher:
+  virtual bool Dispatch(const base::NativeEvent& event) OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(DesktopRootWindowHostOzone);
+};
+
+}  // namespace views
+
+#endif  // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_ROOT_WINDOW_HOST_OZONE_H_
-- 
1.7.9.5