Draggable region support for frameless app window on CrOS.

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"
@@ skipping 483 matching lines @@
   delegate_->GetHitTestMask(&mask);
 
   SkRegion clip_region;
   clip_region.setRect(local_bounds.x(), local_bounds.y(),
                       local_bounds.width(), local_bounds.height());
   SkRegion mask_region;
   return mask_region.setPath(mask, clip_region) &&
       mask_region.contains(local_point.x(), local_point.y());
 }
 
-Window* Window::GetEventHandlerForPoint(const gfx::Point& local_point) {
-  return GetWindowForPoint(local_point, true, true);
+Window* Window::GetEventHandlerForPoint(const gfx::Point& local_point,
+                                        ui::EventType event_type) {
+  return GetWindowForPoint(local_point, true, event_type);
 }
 
 Window* Window::GetTopWindowContainingPoint(const gfx::Point& local_point) {
-  return GetWindowForPoint(local_point, false, false);
+  return GetWindowForPoint(local_point, false, ui::ET_UNKNOWN);
 }
 
 Window* Window::GetToplevelWindow() {
   Window* topmost_window_with_delegate = NULL;
   for (aura::Window* window = this; window != NULL; window = window->parent()) {
     if (window->delegate())
       topmost_window_with_delegate = window;
   }
   return topmost_window_with_delegate;
 }
@@ skipping 173 matching lines @@
   if (root_window)
     root_window->OnWindowVisibilityChanged(this, visible);
 }
 
 void Window::SchedulePaint() {
   SchedulePaintInRect(gfx::Rect(0, 0, bounds().width(), bounds().height()));
 }
 
 Window* Window::GetWindowForPoint(const gfx::Point& local_point,
                                   bool return_tightest,
-                                  bool for_event_handling) {
+                                  ui::EventType event_type) {
   if (!IsVisible())
     return NULL;
 
+  bool for_event_handling = event_type != ui::ET_UNKNOWN;
   if ((for_event_handling && !HitTest(local_point)) ||
       (!for_event_handling && !ContainsPoint(local_point)))
     return NULL;
 
   // Check if I should claim this event and not pass it to my children because
   // the location is inside my hit test override area.  For details, see
   // set_hit_test_bounds_override_inner().
   if (for_event_handling && !hit_test_bounds_override_inner_.empty()) {
     gfx::Rect inset_local_bounds(gfx::Point(), bounds().size());
     inset_local_bounds.Inset(hit_test_bounds_override_inner_);
@@ skipping 21 matching lines @@
 
     // 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);
     ConvertPointToTarget(this, child, &point_in_child_coords);
     if (for_event_handling && delegate_ &&
         !delegate_->ShouldDescendIntoChildForEventHandling(
-            child, local_point)) {
+            child, local_point, event_type)) {
       continue;
     }
 
     Window* match = child->GetWindowForPoint(point_in_child_coords,
                                              return_tightest,
-                                             for_event_handling);
+                                             event_type);
     if (match)
       return match;
   }
 
   return delegate_ ? this : NULL;
 }
 
 void Window::RemoveChildImpl(Window* child, Window* new_parent) {
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
@@ skipping 190 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