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_);
     // We know we're inside the normal local bounds, so if we're outside the
     // inset bounds we must be in the special hit test override area.
     DCHECK(HitTest(local_point));
     if (!inset_local_bounds.Contains(local_point))
       return delegate_ ? this : NULL;
   }
 
+  // Check if I should claim the mouse click/drag event and not pass it to my
+  // children because this location is inside the draggable region.
+  if (delegate_ &&
+      (event_type == ui::ET_MOUSE_PRESSED ||
+           event_type == ui::ET_MOUSE_DRAGGED ||
+           event_type == ui::ET_MOUSE_RELEASED) &&
+      draggable_region_.get() &&
+      draggable_region_->contains(local_point.x(), local_point.y()))
+    return this;
+
   if (!return_tightest && delegate_)
     return this;
 
   for (Windows::const_reverse_iterator it = children_.rbegin(),
            rend = children_.rend();
        it != rend; ++it) {
     Window* child = *it;
 
     if (for_event_handling) {
       // The client may not allow events to be processed by certain subtrees.
@@ skipping 10 matching lines @@
     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)) {
       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 169 matching lines @@
 bool Window::ContainsMouse() {
   bool contains_mouse = false;
   if (IsVisible()) {
     RootWindow* root_window = GetRootWindow();
     contains_mouse = root_window &&
         ContainsPointInRoot(root_window->GetLastMouseLocationInRoot());
   }
   return contains_mouse;
 }
 
+void Window::SetDraggableRegion(SkRegion* region) {
+  draggable_region_.reset(region);
+}
+
 #ifndef NDEBUG
 std::string Window::GetDebugInfo() const {
   return StringPrintf(
       "%s<%d> bounds(%d, %d, %d, %d) %s",
       name().empty() ? "Unknown" : name().c_str(), id(),
       bounds().x(), bounds().y(), bounds().width(), bounds().height(),
       IsVisible() ? "Visible" : "Hidden");
 }
 
 void Window::PrintWindowHierarchy(int depth) const {
   printf("%*s%s\n", depth * 2, "", GetDebugInfo().c_str());
   for (Windows::const_reverse_iterator it = children_.rbegin(),
            rend = children_.rend();
        it != rend; ++it) {
     Window* child = *it;
     child->PrintWindowHierarchy(depth + 1);
   }
 }
 #endif
 
 }  // namespace aura