gesture recognizer: Expose bounding-box for the points in a gesture-event.

ui/aura/gestures/gesture_recognizer_unittest.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 "base/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
@@ skipping 33 matching lines @@
         scroll_end_(false),
         pinch_begin_(false),
         pinch_update_(false),
         pinch_end_(false),
         long_press_(false),
         fling_(false),
         two_finger_tap_(false),
         scroll_x_(0),
         scroll_y_(0),
         velocity_x_(0),
-        velocity_y_(0),
-        radius_x_(0),
-        radius_y_(0) {
+        velocity_y_(0) {
   }
 
   virtual ~GestureEventConsumeDelegate() {}
 
   void Reset() {
     tap_ = false;
     tap_down_ = false;
     begin_ = false;
     end_ = false;
     double_tap_ = false;
     scroll_begin_ = false;
     scroll_update_ = false;
     scroll_end_ = false;
     pinch_begin_ = false;
     pinch_update_ = false;
     pinch_end_ = false;
     long_press_ = false;
     fling_ = false;
     two_finger_tap_ = false;
 
     scroll_begin_position_.SetPoint(0, 0);
     tap_location_.SetPoint(0, 0);
 
     scroll_x_ = 0;
     scroll_y_ = 0;
     velocity_x_ = 0;
     velocity_y_ = 0;
-    radius_x_ = 0;
-    radius_y_ = 0;
   }
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
   bool begin() const { return begin_; }
   bool end() const { return end_; }
   bool double_tap() const { return double_tap_; }
   bool scroll_begin() const { return scroll_begin_; }
   bool scroll_update() const { return scroll_update_; }
   bool scroll_end() const { return scroll_end_; }
@@ skipping 10 matching lines @@
 
   const gfx::Point tap_location() const {
     return tap_location_;
   }
 
   float scroll_x() const { return scroll_x_; }
   float scroll_y() const { return scroll_y_; }
   int touch_id() const { return touch_id_; }
   float velocity_x() const { return velocity_x_; }
   float velocity_y() const { return velocity_y_; }
-  float radius_x() const { return radius_x_; }
-  float radius_y() const { return radius_y_; }
+  const gfx::Rect& bounding_box() const { return bounding_box_; }
 
   virtual ui::GestureStatus OnGestureEvent(GestureEvent* gesture) OVERRIDE {
+    bounding_box_ = gesture->details().bounding_box();
     switch (gesture->type()) {
       case ui::ET_GESTURE_TAP:
-        radius_x_ = gesture->details().radius_x();
-        radius_y_ = gesture->details().radius_y();
         tap_location_ = gesture->location();
         tap_ = true;
         break;
       case ui::ET_GESTURE_TAP_DOWN:
         tap_down_ = true;
         break;
       case ui::ET_GESTURE_BEGIN:
         begin_ = true;
         break;
       case ui::ET_GESTURE_END:
@@ skipping 59 matching lines @@
   bool fling_;
   bool two_finger_tap_;
 
   gfx::Point scroll_begin_position_;
   gfx::Point tap_location_;
 
   float scroll_x_;
   float scroll_y_;
   float velocity_x_;
   float velocity_y_;
-  int radius_x_;
-  int radius_y_;
   int touch_id_;
+  gfx::Rect bounding_box_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(RootWindow* root_window)
       : window_(NULL),
         root_window_(root_window) {
   }
@@ skipping 266 matching lines @@
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      gfx::Point actual_point(delegate->tap_location());
-     EXPECT_EQ(12, delegate->radius_x());
-     EXPECT_EQ(12, delegate->radius_y());
+     EXPECT_EQ(24, delegate->bounding_box().width());
+     EXPECT_EQ(24, delegate->bounding_box().height());
      EXPECT_EQ(100, actual_point.x());
      EXPECT_EQ(200, actual_point.y());
   }
 
   // Test with no ET_TOUCH_MOVED events but different touch points and radii.
   {
      delegate->Reset();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(365, 290),
                       kTouchId, GetTime());
      press.set_radius_x(8);
@@ skipping 19 matching lines @@
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      gfx::Point actual_point(delegate->tap_location());
-     EXPECT_EQ(23, delegate->radius_x());
-     EXPECT_EQ(20, delegate->radius_y());
+     EXPECT_EQ(46, delegate->bounding_box().width());
+     EXPECT_EQ(40, delegate->bounding_box().height());
      EXPECT_EQ(373, actual_point.x());
      EXPECT_EQ(290, actual_point.y());
   }
 
   // Test with a single ET_TOUCH_MOVED event.
   {
      delegate->Reset();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(46, 205),
                       kTouchId, GetTime());
      press.set_radius_x(6);
@@ skipping 35 matching lines @@
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      gfx::Point actual_point(delegate->tap_location());
-     EXPECT_EQ(14, delegate->radius_x());
-     EXPECT_EQ(14, delegate->radius_y());
+     EXPECT_EQ(28, delegate->bounding_box().width());
+     EXPECT_EQ(28, delegate->bounding_box().height());
      EXPECT_EQ(49, actual_point.x());
      EXPECT_EQ(200, actual_point.y());
   }
 
   // Test with a few ET_TOUCH_MOVED events.
   {
      delegate->Reset();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(400, 150),
                       kTouchId, GetTime());
      press.set_radius_x(7);
@@ skipping 67 matching lines @@
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      gfx::Point actual_point(delegate->tap_location());
-     EXPECT_EQ(17, delegate->radius_x());
-     EXPECT_EQ(18, delegate->radius_y());
+     EXPECT_EQ(35, delegate->bounding_box().width());
+     EXPECT_EQ(36, delegate->bounding_box().height());
      EXPECT_EQ(396, actual_point.x());
      EXPECT_EQ(149, actual_point.y());
   }
 }
 
 // Check that appropriate touch events generate scroll gesture events.
 TEST_F(GestureRecognizerTest, GestureEventScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
@@ skipping 1608 matching lines @@
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_TRUE(delegate->scroll_end());
 }
 
 }  // namespace test
 }  // namespace aura