SearchBoxView now enables/disables cursor based on user interaction.

ui/app_list/views/app_list_view.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/app_list/views/app_list_view.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 181 matching lines @@
 // AppListView:
 
 AppListView::AppListView(AppListViewDelegate* delegate)
     : delegate_(delegate),
       app_list_main_view_(nullptr),
       speech_view_(nullptr),
       search_box_focus_host_(nullptr),
       search_box_widget_(nullptr),
       search_box_view_(nullptr),
       is_fullscreen_app_list_enabled_(features::IsFullscreenAppListEnabled()),
+      processing_scroll_event_series_(false),
       app_list_state_(PEEKING),
       display_observer_(this),
       overlay_view_(nullptr),
       animation_observer_(new HideViewAnimationObserver()) {
   CHECK(delegate);
   delegate_->GetSpeechUI()->AddObserver(this);
 
   if (is_fullscreen_app_list_enabled_)
     display_observer_.Add(display::Screen::GetScreen());
 }
@@ skipping 276 matching lines @@
 
   aura::Window* window = GetWidget()->GetNativeWindow();
   window->SetEventTargeter(base::MakeUnique<views::BubbleWindowTargeter>(this));
 
   const int kOverlayCornerRadius =
       GetBubbleFrameView()->bubble_border()->GetBorderCornerRadius();
   overlay_view_ = new AppListOverlayView(kOverlayCornerRadius);
   overlay_view_->SetBoundsRect(GetContentsBounds());
 }
 
+void AppListView::HandleClickOrTap() {
+  switch (app_list_state_) {
+    case HALF:
+    case FULLSCREEN_SEARCH:
+      search_box_view_->ClearSearch();
+      SetState(app_list_state_ == HALF ? PEEKING : FULLSCREEN_ALL_APPS);
+      break;
+    case PEEKING:
+    case FULLSCREEN_ALL_APPS:
+      if (search_box_view_->is_search_box_active())
+        search_box_view_->ClearSearch();
+      else
+        SetState(CLOSED);
+      break;
+    default:

[oshima, 2017/07/05 19:11:59]

add

case CLOSED:
  break

and remove default. This way, compiler can catch when you add new enum member
but forgot to handle it.

[newcomer, 2017/07/05 22:03:57]

Done, thanks!

+      break;
+  }
+}
+
 void AppListView::StartDrag(const gfx::Point& location) {
   initial_drag_point_ = location;
 }
 
 void AppListView::UpdateDrag(const gfx::Point& location) {
   // Update the bounds of the widget while maintaining the
   // relative position of the top of the widget and the mouse/gesture.
   // Block drags north of 0 and recalculate the initial_drag_point_.
   int const new_y_position = location.y() - initial_drag_point_.y() +
                              fullscreen_widget_->GetWindowBoundsInScreen().y();
   gfx::Rect new_widget_bounds = fullscreen_widget_->GetWindowBoundsInScreen();
   if (new_y_position < 0) {
     new_widget_bounds.set_y(0);
     initial_drag_point_ = location;
   } else {
     new_widget_bounds.set_y(new_y_position);
   }
   fullscreen_widget_->SetBounds(new_widget_bounds);
 }
 
 void AppListView::EndDrag(const gfx::Point& location) {
+  // When the SearchBoxView closes the app list, ignore the final event.
+  if (app_list_state_ == CLOSED)
+    return;
   // Change the app list state based on where the drag ended. If fling velocity
   // was over the threshold, snap to the next state in the direction of the
   // fling.
   int const new_y_position = location.y() - initial_drag_point_.y() +
                              fullscreen_widget_->GetWindowBoundsInScreen().y();
   if (std::abs(last_fling_velocity_) > kAppListDragVelocityThreshold) {
     // If the user releases drag with velocity over the threshold, snap to
     // the next state, ignoring the drag release position.
 
     if (last_fling_velocity_ > 0) {
@@ skipping 167 matching lines @@
 
   mask->addRect(gfx::RectToSkRect(GetBubbleFrameView()->GetContentsBounds()));
 }
 
 void AppListView::OnMouseEvent(ui::MouseEvent* event) {
   if (!is_fullscreen_app_list_enabled_)
     return;
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
-      StartDrag(event->location());
       event->SetHandled();
-      break;
-    case ui::ET_MOUSE_DRAGGED:
-      UpdateDrag(event->location());
-      event->SetHandled();
-      break;
-    case ui::ET_MOUSE_RELEASED:
-      EndDrag(event->location());
-      event->SetHandled();
+      HandleClickOrTap();
       break;
     default:
       break;
   }
 }
 
 void AppListView::OnGestureEvent(ui::GestureEvent* event) {
   if (!is_fullscreen_app_list_enabled_)
     return;
 
   switch (event->type()) {
+    case ui::ET_GESTURE_TAP:
+      processing_scroll_event_series_ = false;
+      event->SetHandled();
+      HandleClickOrTap();
+      break;
+    case ui::ET_SCROLL_FLING_START:
     case ui::ET_GESTURE_SCROLL_BEGIN:
+      processing_scroll_event_series_ = true;
       StartDrag(event->location());
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE:
-      last_fling_velocity_ = event->details().velocity_y();
+      processing_scroll_event_series_ = true;
+      last_fling_velocity_ = event->details().scroll_y();
       UpdateDrag(event->location());
       event->SetHandled();
       break;
     case ui::ET_GESTURE_END:
+      if (!processing_scroll_event_series_)
+        break;
+
+      processing_scroll_event_series_ = false;
       EndDrag(event->location());
       event->SetHandled();
       break;
     default:
       break;
   }
 }
 
 bool AppListView::AcceleratorPressed(const ui::Accelerator& accelerator) {
   DCHECK_EQ(ui::VKEY_ESCAPE, accelerator.key_code());
@@ skipping 211 matching lines @@
                        .work_area()
                        .size();
   size.Enlarge(0, kShelfSize);
   fullscreen_widget_->SetSize(size);
 
   // Update the |fullscreen_widget_| bounds to accomodate the new work area.
   SetState(app_list_state_);
 }
 
 }  // namespace app_list