Convert Aura to use ui::Event.

ui/aura/window.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.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
@@ skipping 203 matching lines @@
   return visible_ && layer_ && layer_->IsDrawn();
 }
 
 gfx::Rect Window::GetBoundsInRootWindow() const {
   // TODO(beng): There may be a better way to handle this, and the existing code
   //             is likely wrong anyway in a multi-display world, but this will
   //             do for now.
   if (!GetRootWindow())
     return bounds();
   gfx::Point origin = bounds().origin();
-  Window::ConvertPointToWindow(parent_, GetRootWindow(), &origin);
+  ConvertPointToTarget(parent_, GetRootWindow(), &origin);
   return gfx::Rect(origin, bounds().size());
 }
 
 gfx::Rect Window::GetBoundsInScreen() const {
   gfx::Rect bounds(GetBoundsInRootWindow());
   const RootWindow* root = GetRootWindow();
   if (root) {
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     if (screen_position_client) {
@@ skipping 168 matching lines @@
     if ((*i)->id() == id)
       return *i;
     const Window* result = (*i)->GetChildById(id);
     if (result)
       return result;
   }
   return NULL;
 }
 
 // static
-void Window::ConvertPointToWindow(const Window* source,
+void Window::ConvertPointToTarget(const Window* source,
                                   const Window* target,
                                   gfx::Point* point) {
   if (!source)
     return;
   if (source->GetRootWindow() != target->GetRootWindow()) {
     const gfx::Point source_origin =
         gfx::Screen::GetDisplayNearestWindow(
             const_cast<Window*>(source)).bounds().origin();
     const gfx::Point target_origin =
         gfx::Screen::GetDisplayNearestWindow(
             const_cast<Window*>(target)).bounds().origin();
     ui::Layer::ConvertPointToLayer(
         source->layer(), source->GetRootWindow()->layer(), point);
     const gfx::Point offset = source_origin.Subtract(target_origin);
     point->Offset(offset.x(), offset.y());
     ui::Layer::ConvertPointToLayer(
         target->GetRootWindow()->layer(), target->layer(), point);
   } else {
     ui::Layer::ConvertPointToLayer(source->layer(), target->layer(), point);
   }
 }
 
 void Window::MoveCursorTo(const gfx::Point& point_in_window) {
   RootWindow* root_window = GetRootWindow();
   DCHECK(root_window);
   gfx::Point point_in_root(point_in_window);
-  ConvertPointToWindow(this, root_window, &point_in_root);
+  ConvertPointToTarget(this, root_window, &point_in_root);
   root_window->MoveCursorTo(point_in_root);
 }
 
 gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
   return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
 }
 
 void Window::SetEventFilter(EventFilter* event_filter) {
   event_filter_.reset(event_filter);
 }
 
 void Window::AddObserver(WindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void Window::RemoveObserver(WindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool Window::ContainsPointInRoot(const gfx::Point& point_in_root) const {
   const Window* root_window = GetRootWindow();
   if (!root_window)
     return false;
   gfx::Point local_point(point_in_root);
-  ConvertPointToWindow(root_window, this, &local_point);
+  ConvertPointToTarget(root_window, this, &local_point);
   return gfx::Rect(GetTargetBounds().size()).Contains(local_point);
 }
 
 bool Window::ContainsPoint(const gfx::Point& local_point) const {
   return gfx::Rect(bounds().size()).Contains(local_point);
 }
 
 bool Window::HitTest(const gfx::Point& local_point) {
   // Expand my bounds for hit testing (override is usually zero but it's
   // probably cheaper to do the math every time than to branch).
@@ skipping 248 matching lines @@
       if (client && !client->CanProcessEventsWithinSubtree(child))
         continue;
     }
 
     // We don't process events for invisible windows or those that have asked
     // to ignore events.
     if (!child->IsVisible() || (for_event_handling && child->ignore_events_))
       continue;
 
     gfx::Point point_in_child_coords(local_point);
-    Window::ConvertPointToWindow(this, child, &point_in_child_coords);
+    ConvertPointToTarget(this, child, &point_in_child_coords);
     if (for_event_handling && delegate_ &&
         !delegate_->ShouldDescendIntoChildForEventHandling(
             child, local_point)) {
       continue;
     }
 
     Window* match = child->GetWindowForPoint(point_in_child_coords,
                                              return_tightest,
                                              for_event_handling);
     if (match)
@@ skipping 175 matching lines @@
   for (Windows::const_reverse_iterator it = children_.rbegin(),
            rend = children_.rend();
        it != rend; ++it) {
     Window* child = *it;
     child->PrintWindowHierarchy(depth + 1);
   }
 }
 #endif
 
 }  // namespace aura