Aura/ash: On Desktops, use a aura::client to resolve screen coordinates.

ui/views/widget/desktop_native_widget_helper_aura.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/views/widget/desktop_native_widget_helper_aura.h"
 
 #include "ui/aura/root_window.h"
 #include "ui/aura/desktop/desktop_activation_client.h"
 #include "ui/aura/desktop/desktop_dispatcher_client.h"
 #include "ui/aura/client/dispatcher_client.h"
+#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/shared/input_method_event_filter.h"
 #include "ui/aura/shared/root_window_event_filter.h"
 #include "ui/views/widget/native_widget_aura.h"
 
 #if defined(OS_WIN)
 #include "ui/base/win/hwnd_subclass.h"
 #include "ui/views/widget/widget_message_filter.h"
 #elif defined(USE_X11)
 #include "ui/views/widget/x11_window_event_filter.h"
 #endif
 
 namespace views {
 
+namespace {
+
+// Client that always offsets the passed in point by the RootHost's origin.
+class RootWindowScreenPositionClient
+    : public aura::client::ScreenPositionClient {
+ public:
+  explicit RootWindowScreenPositionClient(aura::RootWindow* root_window)
+      : root_window_(root_window) {}
+  virtual ~RootWindowScreenPositionClient() {}
+
+  // aura::client::ScreenPositionClient:
+  virtual void ConvertToScreenPoint(gfx::Point* screen_point) OVERRIDE {
+    gfx::Point origin = root_window_->GetHostOrigin();
+    screen_point->Offset(origin.x(), origin.y());
+  }
+
+ private:
+  aura::RootWindow* root_window_;
+};
+
+// Client that always offsets by the toplevel RootWindow of the passed in child
+// NativeWidgetAura.
+class EmbeddedWindowScreenPositionClient
+    : public aura::client::ScreenPositionClient {
+ public:
+  explicit EmbeddedWindowScreenPositionClient(NativeWidgetAura* widget)
+      : widget_(widget) {}
+  virtual ~EmbeddedWindowScreenPositionClient() {}
+
+  // aura::client::ScreenPositionClient:
+  virtual void ConvertToScreenPoint(gfx::Point* screen_point) OVERRIDE {
+    aura::RootWindow* root =
+        widget_->GetNativeWindow()->GetRootWindow()->GetRootWindow();
+    gfx::Point origin = root->GetHostOrigin();
+    screen_point->Offset(origin.x(), origin.y());
+  }
+
+ private:
+  NativeWidgetAura* widget_;
+};
+
+}  // namespace
+
 DesktopNativeWidgetHelperAura::DesktopNativeWidgetHelperAura(
     NativeWidgetAura* widget)
     : widget_(widget),
       root_window_event_filter_(NULL),
       is_embedded_window_(false) {
 }
 
 DesktopNativeWidgetHelperAura::~DesktopNativeWidgetHelperAura() {
   if (root_window_event_filter_) {
 #if defined(USE_X11)
     root_window_event_filter_->RemoveFilter(x11_window_event_filter_.get());
 #endif
 
     root_window_event_filter_->RemoveFilter(input_method_filter_.get());
   }
 }
 
 void DesktopNativeWidgetHelperAura::PreInitialize(
+    aura::Window* window,
     const Widget::InitParams& params) {
 #if !defined(OS_WIN)
   // We don't want the status bubble or the omnibox to get their own root
   // window on the desktop; on Linux
   //
   // TODO(erg): This doesn't map perfectly to what I want to do. TYPE_POPUP is
   // used for lots of stuff, like dragged tabs, and I only want this to trigger
   // for the status bubble and the omnibox.
   if (params.type == Widget::InitParams::TYPE_POPUP) {
     is_embedded_window_ = true;
+    position_client_.reset(new EmbeddedWindowScreenPositionClient(widget_));
+    aura::client::SetScreenPositionClient(window, position_client_.get());
     return;
   } else if (params.type == Widget::InitParams::TYPE_CONTROL) {
     return;
   }
 #endif
 
   gfx::Rect bounds = params.bounds;
   if (bounds.IsEmpty()) {
     // We must pass some non-zero value when we initialize a RootWindow. This
     // will probably be SetBounds()ed soon.
@@ skipping 16 matching lines @@
   root_window_event_filter_->AddFilter(x11_window_event_filter_.get());
 #endif
 
   root_window_->AddRootWindowObserver(this);
 
   aura::client::SetActivationClient(
       root_window_.get(),
       new aura::DesktopActivationClient(root_window_.get()));
   aura::client::SetDispatcherClient(root_window_.get(),
                                     new aura::DesktopDispatcherClient);
+
+  position_client_.reset(
+      new RootWindowScreenPositionClient(root_window_.get()));
+  aura::client::SetScreenPositionClient(window, position_client_.get());
 }
 
 void DesktopNativeWidgetHelperAura::PostInitialize() {
 #if defined(OS_WIN)
   subclass_.reset(new ui::HWNDSubclass(root_window_->GetAcceleratedWidget()));
   subclass_->SetFilter(new WidgetMessageFilter(root_window_.get(),
                                                widget_->GetWidget()));
 #endif
 }
 
@@ skipping 20 matching lines @@
     aura::RootWindow* root =
         widget_->GetNativeWindow()->GetRootWindow()->GetRootWindow();
     gfx::Point point = root->GetHostOrigin();
     out_bounds.set_x(out_bounds.x() - point.x());
     out_bounds.set_y(out_bounds.y() - point.y());
   }
 
   return out_bounds;
 }
 
-gfx::Rect DesktopNativeWidgetHelperAura::ChangeRootWindowBoundsToScreenBounds(
-    const gfx::Rect& bounds) {
-  gfx::Rect out_bounds = bounds;
-  if (root_window_.get()) {
-    out_bounds.Offset(root_window_->GetHostOrigin());
-  } else if (is_embedded_window_) {
-    aura::RootWindow* root =
-        widget_->GetNativeWindow()->GetRootWindow()->GetRootWindow();
-    out_bounds.Offset(root->GetHostOrigin());
-  }
-  return out_bounds;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetHelperAura, aura::RootWindowObserver implementation:
 
 void DesktopNativeWidgetHelperAura::OnRootWindowResized(
     const aura::RootWindow* root,
     const gfx::Size& old_size) {
   DCHECK_EQ(root, root_window_.get());
   widget_->SetBounds(gfx::Rect(root->GetHostOrigin(),
                                root->GetHostSize()));
 }
 
 void DesktopNativeWidgetHelperAura::OnRootWindowHostClosed(
     const aura::RootWindow* root) {
   DCHECK_EQ(root, root_window_.get());
   widget_->GetWidget()->Close();
 }
 
 }  // namespace views