Simplify HomeCardGestureManager::UpdateScrollState()

This CL:
- Prevents HomeCardGestureManager from calling OnGestureProgressed() with
  |from_state| == |to_state|
  - This fixes the minimized home card's opacity being incorrectly set when
    dragging down from the minimized state
- Removes unnecessary |HomeCardGestureManager::last_state_|

BUG=409666
TEST=HomeCardGestureManagerTest.*

Review URL: https://codereview.chromium.org/529813002

Cr-Commit-Position: refs/heads/master@{#293232}

athena/home/home_card_gesture_manager.cc

@@ -12,7 +12,6 @@ namespace athena {
 HomeCardGestureManager::HomeCardGestureManager(Delegate* delegate,
                                                const gfx::Rect& screen_bounds)
     : delegate_(delegate),
-      last_state_(HomeCard::Get()->GetState()),
       y_offset_(0),
       last_estimated_height_(0),
       screen_bounds_(screen_bounds) {}
@@ -75,16 +74,15 @@ void HomeCardGestureManager::UpdateScrollState(const ui::GestureEvent& event) {
 
   if (last_estimated_height_ <= kHomeCardMinimizedHeight) {
     delegate_->OnGestureProgressed(
-        last_state_, HomeCard::VISIBLE_MINIMIZED, 1.0f);
-    last_state_ = HomeCard::VISIBLE_MINIMIZED;
+        HomeCard::VISIBLE_BOTTOM, HomeCard::VISIBLE_MINIMIZED, 1.0f);
     return;
   }
 
-  HomeCard::State state = HomeCard::VISIBLE_BOTTOM;
+  HomeCard::State bigger_state = HomeCard::VISIBLE_BOTTOM;
   float smaller_height = kHomeCardMinimizedHeight;
   float bigger_height = kHomeCardHeight;
   if (last_estimated_height_ > kHomeCardHeight) {
-    state = HomeCard::VISIBLE_CENTERED;
+    bigger_state = HomeCard::VISIBLE_CENTERED;
     smaller_height = kHomeCardHeight;
     bigger_height = screen_bounds_.height();
   }
@@ -94,16 +92,10 @@ void HomeCardGestureManager::UpdateScrollState(const ui::GestureEvent& event) {
       (bigger_height - smaller_height);
   progress = std::min(1.0f, std::max(0.0f, progress));
 
-  if (last_state_ == state) {
-    if (event.details().scroll_y() > 0) {
-      state = static_cast<HomeCard::State>(state + 1);
-      progress = 1.0f - progress;
-    } else {
-      last_state_ = static_cast<HomeCard::State>(last_state_ + 1);
-    }
-  }
-  delegate_->OnGestureProgressed(last_state_, state, progress);
-  last_state_ = state;
+  delegate_->OnGestureProgressed(
+      static_cast<HomeCard::State>(bigger_state + 1),
+      bigger_state,
+      progress);
 }
 
 }  // namespace athena

athena/home/home_card_gesture_manager.h

@@ -24,13 +24,13 @@ class ATHENA_EXPORT HomeCardGestureManager {
     // end up with |final_state|.
     virtual void OnGestureEnded(HomeCard::State final_state) = 0;
 
-    // Called when the gesture position is updated so that |delegate| should
-    // update the visual. The arguments represent the state of the current
-    // gesture position is switching from |from_state| to |to_state|, and
-    // the level of the progress is at |progress|, which is 0 to 1.
-    // |from_state| and |to_state| could be same. For example, if the user moves
-    // the finger down to the bottom of the screen, both states are MINIMIZED.
-    // In that case |progress| is 0.
+    // Called when the gesture position is updated so that |delegate| updates
+    // the visual. The arguments indicate that the gesture is switching between
+    // |from_state| and |to_state|, and that the level of progress is at
+    // |progress|, which is in the range (0, 1]. The home card was previously
+    // at either |from_state| or |to_state|. In particular, the home card may
+    // never have been at |from_state|. |from_state| is never equal to
+    // |to_state|.
     virtual void OnGestureProgressed(
         HomeCard::State from_state,
         HomeCard::State to_state,
@@ -51,7 +51,6 @@ class ATHENA_EXPORT HomeCardGestureManager {
   void UpdateScrollState(const ui::GestureEvent& event);
 
   Delegate* delegate_;  // Not owned.
-  HomeCard::State last_state_;
 
   // The offset from the top edge of the home card and the initial position of
   // gesture.

athena/home/home_card_gesture_manager_unittest.cc

@@ -48,11 +48,18 @@ class HomeCardGestureManagerTest : public test::AthenaTestBase,
   bool ProcessGestureEvent(ui::EventType type, int y) {
     ui::GestureEvent event(0, y, ui::EF_NONE, base::TimeDelta(),
                            ui::GestureEventDetails(type, 0, (y - last_y_)));
-    // Assumes the initial location is based on minimized height.
     if (type == ui::ET_GESTURE_SCROLL_BEGIN) {
+      // Compute the position that the home card would have wrt to the top of
+      // the screen if the screen had screen_bounds().
+      HomeCard::State state = HomeCard::Get()->GetState();
+      int home_card_top = 0;
+      if (state == HomeCard::VISIBLE_BOTTOM)
+        home_card_top = screen_bounds().height() - kHomeCardHeight;
+      else if (state == HomeCard::VISIBLE_MINIMIZED)
+        home_card_top = screen_bounds().height() - kHomeCardMinimizedHeight;
+
       gfx::Point location = event.location();
-      location.set_y(
-          location.y() - (screen_bounds().bottom() - kHomeCardMinimizedHeight));
+      location.set_y(location.y() - home_card_top);
       event.set_location(location);
     }
     gesture_manager_->ProcessGestureEvent(&event);
@@ -100,6 +107,8 @@ class HomeCardGestureManagerTest : public test::AthenaTestBase,
 };
 
 TEST_F(HomeCardGestureManagerTest, Basic) {
+  ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState());
+
   EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020));
   EXPECT_EQ(0, GetEndCountAndReset());
   EXPECT_EQ(0, GetProgressCountAndReset());
@@ -110,6 +119,13 @@ TEST_F(HomeCardGestureManagerTest, Basic) {
   EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_to_state_);
   EXPECT_GT(1.0f, last_progress_);
 
+  ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1020);
+  ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1022);
+  EXPECT_EQ(2, GetProgressCountAndReset());
+  EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_);
+  EXPECT_EQ(HomeCard::VISIBLE_MINIMIZED, last_to_state_);
+  EXPECT_EQ(1.0f, last_progress_);
+
   ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1010);
   float progress_1010 = last_progress_;
   ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 1008);
@@ -134,16 +150,44 @@ TEST_F(HomeCardGestureManagerTest, Basic) {
   EXPECT_LT(progress_800, last_progress_);
 
   ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 810);
-  EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_from_state_);
-  EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_to_state_);
-  EXPECT_GT(progress_800, (1.0f - last_progress_));
+  EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_);
+  EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_);
+  EXPECT_GT(progress_800, last_progress_);
 
   EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 810));
   EXPECT_EQ(1, GetEndCountAndReset());
   EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_);
 }
 
+// Test gesture progress when the gesture is initiated when the home card is in
+// the centered state.
+TEST_F(HomeCardGestureManagerTest, StartCentered) {
+  HomeCard::Get()->SetState(HomeCard::VISIBLE_CENTERED);
+
+  EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 20));
+
+  ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 10);
+  EXPECT_EQ(1, GetProgressCountAndReset());
+  EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_);
+  EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_);
+  EXPECT_EQ(1.0f, last_progress_);
+
+  ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 900);
+  ProcessGestureEvent(ui::ET_GESTURE_SCROLL_UPDATE, 910);
+  EXPECT_EQ(2, GetProgressCountAndReset());
+  EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, last_from_state_);
+  EXPECT_EQ(HomeCard::VISIBLE_CENTERED, last_to_state_);
+  EXPECT_GT(1.0f, last_progress_);
+  EXPECT_LT(0.0f, last_progress_);
+
+  EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_END, 1000));
+  EXPECT_EQ(1, GetEndCountAndReset());
+  EXPECT_EQ(HomeCard::VISIBLE_BOTTOM, final_state_);
+}
+
 TEST_F(HomeCardGestureManagerTest, FlingUpAtEnd) {
+  ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState());
+
   EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020));
   EXPECT_EQ(0, GetEndCountAndReset());
   EXPECT_EQ(0, GetProgressCountAndReset());
@@ -156,6 +200,8 @@ TEST_F(HomeCardGestureManagerTest, FlingUpAtEnd) {
 }
 
 TEST_F(HomeCardGestureManagerTest, FlingDownAtEnd) {
+  ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState());
+
   EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020));
   EXPECT_EQ(0, GetEndCountAndReset());
   EXPECT_EQ(0, GetProgressCountAndReset());
@@ -169,6 +215,8 @@ TEST_F(HomeCardGestureManagerTest, FlingDownAtEnd) {
 }
 
 TEST_F(HomeCardGestureManagerTest, WeakFling) {
+  ASSERT_EQ(HomeCard::VISIBLE_MINIMIZED, HomeCard::Get()->GetState());
+
   EXPECT_TRUE(ProcessGestureEvent(ui::ET_GESTURE_SCROLL_BEGIN, 1020));
   EXPECT_EQ(0, GetEndCountAndReset());
   EXPECT_EQ(0, GetProgressCountAndReset());

athena/home/home_card_impl.cc

@@ -157,10 +157,7 @@ class HomeCardView : public views::WidgetDelegateView {
                         HomeCard::State to_state,
                         float progress) {
     // TODO(mukai): not clear the focus, but simply close the virtual keyboard.
-    if (from_state != HomeCard::VISIBLE_CENTERED ||
-        to_state != HomeCard::VISIBLE_CENTERED) {
-      GetFocusManager()->ClearFocus();
-    }
+    GetFocusManager()->ClearFocus();
     if (from_state == HomeCard::VISIBLE_CENTERED)
       main_view_->SetLayoutState(1.0f - progress);
     else if (to_state == HomeCard::VISIBLE_CENTERED)