SearchBoxView now enables/disables cursor based on user interaction.

ui/app_list/views/search_box_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/search_box_view.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_features.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/app_list_view_delegate.h"
 #include "ui/app_list/resources/grit/app_list_resources.h"
 #include "ui/app_list/search_box_model.h"
 #include "ui/app_list/speech_ui_model.h"
 #include "ui/app_list/vector_icons.h"
+#include "ui/app_list/views/app_list_main_view.h"
 #include "ui/app_list/views/app_list_view.h"
 #include "ui/app_list/views/contents_view.h"
 #include "ui/app_list/views/search_box_view_delegate.h"
+#include "ui/app_list/views/search_result_container_view.h"
+#include "ui/app_list/views/search_result_page_view.h"
 #include "ui/base/ime/text_input_flags.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/shadow_value.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
@@ skipping 21 matching lines @@
 constexpr int kBackgroundBorderCornerRadius = 2;
 constexpr int kBackgroundBorderCornerRadiusFullscreen = 24;
 constexpr int kGoogleIconSize = 24;
 constexpr int kMicIconSize = 24;
 
 // Default color used when wallpaper customized color is not available for
 // searchbox, #000 at 87% opacity.
 constexpr SkColor kDefaultSearchboxColor =
     SkColorSetARGBMacro(0xDE, 0x00, 0x00, 0x00);
 
+// Color of placeholder text in zero query state.
+constexpr SkColor kZeroQuerySearchboxColor =
+    SkColorSetARGBMacro(0x8A, 0x00, 0x00, 0x00);
+
 // A background that paints a solid white rounded rect with a thin grey border.
 class SearchBoxBackground : public views::Background {
  public:
   SearchBoxBackground()
       : background_border_corner_radius_(
             features::IsFullscreenAppListEnabled()
                 ? kBackgroundBorderCornerRadiusFullscreen
                 : kBackgroundBorderCornerRadius) {}
   ~SearchBoxBackground() override {}
 
@@ skipping 91 matching lines @@
       views::BoxLayout::CROSS_AXIS_ALIGNMENT_CENTER);
   layout->set_minimum_cross_axis_size(kPreferredHeight);
 
   search_box_->SetBorder(views::NullBorder());
   search_box_->SetTextColor(kSearchTextColor);
   search_box_->SetBackgroundColor(kSearchBoxBackgroundDefault);
   search_box_->set_controller(this);
   search_box_->SetTextInputType(ui::TEXT_INPUT_TYPE_SEARCH);
   search_box_->SetTextInputFlags(ui::TEXT_INPUT_FLAG_AUTOCORRECT_OFF);
   if (is_fullscreen_app_list_enabled_) {
+    app_list_view_->PrependPreTargetHandler(this);

[oshima, 2017/06/29 16:58:50]

just curious. Why you need to use target handler? (because views will receive
these events)

[newcomer, 2017/06/30 21:47:23]

This has been removed.

There were some issues that I fixed in the leaf views that were preventing the
events from properly propogating to the AppListView. I'll annotate them in the
next patch.

+
     google_icon_ = new views::ImageView();
     google_icon_->SetImage(gfx::CreateVectorIcon(
         kIcGoogleBlackIcon, kGoogleIconSize, kDefaultSearchboxColor));
     content_container_->AddChildView(google_icon_);
 
     search_box_->set_placeholder_text_color(kDefaultSearchboxColor);
     search_box_->set_placeholder_text_draw_flags(
         gfx::Canvas::TEXT_ALIGN_CENTER);
     search_box_->SetFontList(search_box_->GetFontList().DeriveWithSizeDelta(2));
+    search_box_->SetCursorEnabled(is_search_box_active_);
   } else {
     back_button_ = new SearchBoxImageButton(this);
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     back_button_->SetImage(
         views::ImageButton::STATE_NORMAL,
         rb.GetImageSkiaNamed(IDR_APP_LIST_FOLDER_BACK_NORMAL));
     back_button_->SetImageAlignment(views::ImageButton::ALIGN_CENTER,
                                     views::ImageButton::ALIGN_MIDDLE);
     SetBackButtonLabel(false);
     content_container_->AddChildView(back_button_);
 
     search_box_->set_placeholder_text_color(kHintTextColor);
   }
   content_container_->AddChildView(search_box_);
   layout->SetFlexForView(search_box_, 1);
 
   view_delegate_->GetSpeechUI()->AddObserver(this);
   ModelChanged();
 }
 
 SearchBoxView::~SearchBoxView() {
   view_delegate_->GetSpeechUI()->RemoveObserver(this);
   model_->search_box()->RemoveObserver(this);
+  if (is_fullscreen_app_list_enabled_)
+    app_list_view_->RemovePreTargetHandler(this);
 }
 
 void SearchBoxView::ModelChanged() {
   if (model_)
     model_->search_box()->RemoveObserver(this);
 
   model_ = view_delegate_->GetModel();
   DCHECK(model_);
   model_->search_box()->AddObserver(this);
   SpeechRecognitionButtonPropChanged();
   HintTextChanged();
 }
 
 bool SearchBoxView::HasSearch() const {
   return !search_box_->text().empty();
 }
 
 void SearchBoxView::ClearSearch() {
   search_box_->SetText(base::string16());
   view_delegate_->AutoLaunchCanceled();
   // Updates model and fires query changed manually because SetText() above
   // does not generate ContentsChanged() notification.
   UpdateModel();
   NotifyQueryChanged();
+  if (is_fullscreen_app_list_enabled_) {
+    SetSearchBoxActive(false);
+    app_list_view_->SetStateFromSearchBoxView(true);
+  }
 }
 
 void SearchBoxView::SetShadow(const gfx::ShadowValue& shadow) {
   if (is_fullscreen_app_list_enabled_)
     return;
 
   SetBorder(base::MakeUnique<views::ShadowBorder>(shadow));
   Layout();
 }
 
@@ skipping 83 matching lines @@
   if (!back_button_)
     return;
 
   base::string16 back_button_label(l10n_util::GetStringUTF16(
       folder ? IDS_APP_LIST_FOLDER_CLOSE_FOLDER_ACCESSIBILE_NAME
              : IDS_APP_LIST_BACK));
   back_button_->SetAccessibleName(back_button_label);
   back_button_->SetTooltipText(back_button_label);
 }
 
+void SearchBoxView::SetSearchBoxActive(bool active) {
+  if (active == is_search_box_active_)
+    return;
+
+  is_search_box_active_ = active;
+  search_box_->set_placeholder_text_draw_flags(
+      active ? gfx::Canvas::TEXT_ALIGN_LEFT : gfx::Canvas::TEXT_ALIGN_CENTER);
+  search_box_->set_placeholder_text_color(active ? kZeroQuerySearchboxColor
+                                                 : kDefaultSearchboxColor);
+  search_box_->SetCursorEnabled(active);
+  search_box_->SchedulePaint();
+}
+
+void SearchBoxView::HandleSearchBoxEvent(ui::LocatedEvent* located_event,
+                                         ui::EventType type) {
+  if (!is_fullscreen_app_list_enabled_)
+    return;
+  if (type != ui::ET_MOUSE_PRESSED && type != ui::ET_GESTURE_TAP)
+    return;
+
+  bool event_is_in_searchbox_bounds =
+      GetWidget()->GetWindowBoundsInScreen().Contains(
+          located_event->root_location());
+
+  bool event_is_in_search_result_bounds = false;
+  ContentsView* main_contents_view =
+      app_list_view_->app_list_main_view()->contents_view();
+
+  // If a search result is visible check if the event was within its bounds.
+  if (main_contents_view->IsShowingSearchResults()) {
+    View* search_result_contents_view =
+        main_contents_view->search_results_page_view()->contents_view();
+
+    const gfx::Rect search_result_bounds =
+        search_result_contents_view->GetBoundsInScreen();
+    event_is_in_search_result_bounds =
+        search_result_bounds.Contains(located_event->root_location());
+  }
+
+  if (is_search_box_active_ && !event_is_in_searchbox_bounds &&
+      !event_is_in_search_result_bounds) {
+    // If the event was not within searchbox bounds or search result bounds and
+    // the search box is active, close the app list.
+    located_event->SetHandled();
+    app_list_view_->SetState(AppListView::CLOSED);

[xiyuan, 2017/06/27 23:11:10]

It seems we want to dismiss app list when there is a unhandled (click/tap) event
hits the root AppListView. Can we do this in AppListView::OnEvent instead of
installing SearchBoxView as a pre target handler?

[newcomer, 2017/06/30 21:47:23]

Handled offline. We found the problems in the leaf views that were preventing
the events from propogating.

+  } else if (!is_search_box_active_ && event_is_in_searchbox_bounds &&
+             search_box_->text().empty()) {
+    // If the event was within the searchbox bounds and in an inactive empty
+    // search box, enable the search box.
+    SetSearchBoxActive(true);

[xiyuan, 2017/06/27 23:11:10]

This branch is probably not necessary since the events should reach us as
|search_box_| (Textfield) events in OnTextfieldEvent().

[newcomer, 2017/06/30 21:47:23]

It is necessary because there are two regions of the rendered search box, the
textfield and the background(where on mouse hover the mouse does not transition
to the cursor, but the mouse is over the white background of the searchbox).
This branch detects the latter case.

+    located_event->SetHandled();
+  }
+}
+
+bool SearchBoxView::OnTextfieldEvent() {
+  if (!is_search_box_active_) {
+    SetSearchBoxActive(true);
+    return true;
+  } else {
+    return false;
+  }
+}
+
 bool SearchBoxView::OnMouseWheel(const ui::MouseWheelEvent& event) {
   if (contents_view_)
     return contents_view_->OnMouseWheel(event);
 
   return false;
 }
 
 void SearchBoxView::OnEnabledChanged() {
   search_box_->SetEnabled(enabled());
   if (speech_button_)
     speech_button_->SetEnabled(enabled());
 }
 
 const char* SearchBoxView::GetClassName() const {
   return "SearchBoxView";
 }
 
+void SearchBoxView::OnGestureEvent(ui::GestureEvent* event) {
+  HandleSearchBoxEvent(event->AsLocatedEvent(), event->type());

[oshima, 2017/06/29 16:58:50]

AsLocatedEvent is a utility method to downcast from Event class.

You don't need it here because GestureEvent is already LocatedEvent. (and no
need to pass type separately as the event already have it)

You can just do HandleSearchBoxEvent(event);

[newcomer, 2017/06/30 21:47:23]

Done.

+}
+
+void SearchBoxView::OnMouseEvent(ui::MouseEvent* event) {
+  HandleSearchBoxEvent(event->AsLocatedEvent(), event->type());
+}
+
 void SearchBoxView::UpdateModel() {
   // Temporarily remove from observer to ignore notifications caused by us.
   model_->search_box()->RemoveObserver(this);
   model_->search_box()->Update(search_box_->text(), false);
   model_->search_box()->SetSelectionModel(search_box_->GetSelectionModel());
   model_->search_box()->AddObserver(this);
 }
 
 void SearchBoxView::NotifyQueryChanged() {
   DCHECK(delegate_);
   delegate_->QueryChanged(this);
 }
 
 void SearchBoxView::ContentsChanged(views::Textfield* sender,
                                     const base::string16& new_contents) {
   UpdateModel();
   view_delegate_->AutoLaunchCanceled();
   NotifyQueryChanged();
-  if (is_fullscreen_app_list_enabled_)
-    app_list_view_->SetStateFromSearchBoxView(search_box_->text().empty());
+  if (is_fullscreen_app_list_enabled_) {
+    if (is_search_box_active_ == search_box_->text().empty()) {
+      SetSearchBoxActive(!search_box_->text().empty());
+      app_list_view_->SetStateFromSearchBoxView(search_box_->text().empty());
+    }
+  }
 }
 
 bool SearchBoxView::HandleKeyEvent(views::Textfield* sender,
                                    const ui::KeyEvent& key_event) {
   if (key_event.type() == ui::ET_KEY_PRESSED) {
     if (key_event.key_code() == ui::VKEY_TAB &&
         focused_view_ != FOCUS_CONTENTS_VIEW &&
         MoveTabFocus(key_event.IsShiftDown()))
       return true;
 
@@ skipping 33 matching lines @@
         speech_button_->OnKeyReleased(key_event))
       return true;
 
     return contents_view_ && contents_view_->visible() &&
            contents_view_->OnKeyReleased(key_event);
   }
 
   return false;
 }
 
+bool SearchBoxView::HandleMouseEvent(views::Textfield* sender,
+                                     const ui::MouseEvent& mouse_event) {
+  if (!is_fullscreen_app_list_enabled_)
+    return false;
+
+  return OnTextfieldEvent();
+}
+
+bool SearchBoxView::HandleGestureEvent(views::Textfield* sender,
+                                       const ui::GestureEvent& gesture_event) {
+  if (!is_fullscreen_app_list_enabled_)
+    return false;
+
+  return OnTextfieldEvent();
+}
+
 void SearchBoxView::ButtonPressed(views::Button* sender,
                                   const ui::Event& event) {
   if (back_button_ && sender == back_button_)
     delegate_->BackButtonPressed();
   else if (speech_button_ && sender == speech_button_)
     view_delegate_->StartSpeechRecognition();
   else
     NOTREACHED();
 }
 
@@ skipping 54 matching lines @@
   NotifyQueryChanged();
 }
 
 void SearchBoxView::OnSpeechRecognitionStateChanged(
     SpeechRecognitionState new_state) {
   SpeechRecognitionButtonPropChanged();
   SchedulePaint();
 }
 
 }  // namespace app_list