aw: Ensure synchronization of PopupWindow handle visibility/position

ui/touch_selection/touch_selection_controller_unittest.cc

 // Copyright 2014 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/touch_selection/touch_selection_controller.h"
 
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 83 matching lines @@
 
   void MoveRangeSelectionExtent(const gfx::PointF& extent) override {
     selection_moved_ = true;
     selection_end_ = extent;
   }
 
   void OnSelectionEvent(SelectionEventType event) override {
     events_.push_back(event);
     last_event_start_ = controller_->GetStartPosition();
     last_event_end_ = controller_->GetEndPosition();
+    last_event_bounds_rect_ = controller_->GetRectBetweenBounds();
   }
 
   scoped_ptr<TouchHandleDrawable> CreateDrawable() override {
     return make_scoped_ptr(new MockTouchHandleDrawable(&dragging_enabled_));
   }
 
   void AllowShowingOnTapForEmptyEditable() {
     bool show_on_tap_for_empty_editable = true;
     controller_.reset(new TouchSelectionController(
         this,
@@ skipping 72 matching lines @@
     bool swapped = selection_points_swapped_;
     selection_points_swapped_ = false;
     return swapped;
   }
 
   const gfx::PointF& GetLastCaretPosition() const { return caret_position_; }
   const gfx::PointF& GetLastSelectionStart() const { return selection_start_; }
   const gfx::PointF& GetLastSelectionEnd() const { return selection_end_; }
   const gfx::PointF& GetLastEventStart() const { return last_event_start_; }
   const gfx::PointF& GetLastEventEnd() const { return last_event_end_; }
+  const gfx::RectF& GetLastEventBoundsRect() const {
+    return last_event_bounds_rect_;
+  }
 
   std::vector<SelectionEventType> GetAndResetEvents() {
     std::vector<SelectionEventType> events;
     events.swap(events_);
     return events;
   }
 
   TouchSelectionController& controller() { return *controller_; }
 
  private:
   gfx::PointF last_event_start_;
   gfx::PointF last_event_end_;
   gfx::PointF caret_position_;
   gfx::PointF selection_start_;
   gfx::PointF selection_end_;
+  gfx::RectF last_event_bounds_rect_;
   std::vector<SelectionEventType> events_;
   bool caret_moved_;
   bool selection_moved_;
   bool selection_points_swapped_;
   bool needs_animate_;
   bool animation_enabled_;
   bool dragging_enabled_;
   scoped_ptr<TouchSelectionController> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerTest);
@@ skipping 818 matching lines @@
 
   // A point outside the rect should not be handled.
   EXPECT_FALSE(controller().WillHandleLongPressEvent(outer_point));
   EXPECT_THAT(GetAndResetEvents(), IsEmpty());
 
   // A point inside the rect should be handled.
   EXPECT_TRUE(controller().WillHandleLongPressEvent(inner_point));
   EXPECT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
 }
 
+TEST_F(TouchSelectionControllerTest, RectBetweenBounds) {
+  gfx::RectF start_rect(5, 5, 0, 10);
+  gfx::RectF end_rect(50, 5, 0, 10);
+  bool visible = true;
+
+  EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds());
+
+  OnLongPressEvent();
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_SHOWN));
+  EXPECT_EQ(gfx::RectF(5, 5, 45, 10), controller().GetRectBetweenBounds());
+
+  // The result of |GetRectBetweenBounds| should be available within the
+  // |OnSelectionEvent| callback, as stored by |GetLastEventBoundsRect()|.
+  EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
+
+  start_rect.Offset(1, 0);
+  ChangeSelection(start_rect, visible, end_rect, visible);
+  ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
+  EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds());
+  EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
+
+  // If only one bound is visible, the selection bounding rect should reflect
+  // only the visible bound.
+  ChangeSelection(start_rect, visible, end_rect, false);
+  ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
+  EXPECT_EQ(start_rect, controller().GetRectBetweenBounds());
+  EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
+
+  ChangeSelection(start_rect, false, end_rect, visible);
+  ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
+  EXPECT_EQ(end_rect, controller().GetRectBetweenBounds());
+  EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
+
+  // If both bounds are visible, the full bounding rect should be returned.
+  ChangeSelection(start_rect, false, end_rect, false);
+  ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_MOVED));
+  EXPECT_EQ(gfx::RectF(6, 5, 44, 10), controller().GetRectBetweenBounds());
+  EXPECT_EQ(GetLastEventBoundsRect(), controller().GetRectBetweenBounds());
+
+  ClearSelection();
+  ASSERT_THAT(GetAndResetEvents(), ElementsAre(SELECTION_CLEARED));
+  EXPECT_EQ(gfx::RectF(), controller().GetRectBetweenBounds());
+}
+
 }  // namespace ui