Fixes a crash which occurs when a concealed selection handle in a textfield is exposed.

ui/views/touchui/touch_selection_controller_impl.cc

 // Copyright (c) 2013 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/views/touchui/touch_selection_controller_impl.h"
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
@@ skipping 107 matching lines @@
 // Return the appropriate handle image based on the bound's type
 gfx::Image* GetHandleImage(ui::SelectionBound::Type bound_type) {
   switch(bound_type) {
     case ui::SelectionBound::LEFT:
       return GetLeftHandleImage();
     case ui::SelectionBound::CENTER:
       return GetCenterHandleImage();
     case ui::SelectionBound::RIGHT:
       return GetRightHandleImage();
     default:
-      NOTREACHED() << "Invalid touch handle bound type.";
+      NOTREACHED() << "Invalid touch handle bound type: " << bound_type;
       return nullptr;
   };
 }
 
 // Calculates the bounds of the widget containing the selection handle based
 // on the SelectionBound's type and location
 gfx::Rect GetSelectionWidgetBounds(const ui::SelectionBound& bound) {
   gfx::Size image_size = GetHandleImage(bound.type())->Size();
   int widget_width = image_size.width() + 2 * kSelectionHandleHorizPadding;
   int widget_height = bound.GetHeight() + image_size.height() +
@@ skipping 103 matching lines @@
     aura::Window* window = widget_->GetNativeWindow();
     window->SetEventTargeter(std::unique_ptr<ui::EventTargeter>(
         new TouchHandleWindowTargeter(window, this)));
 
     // We are owned by the TouchSelectionControllerImpl.
     set_owned_by_client();
   }
 
   ~EditingHandleView() override { SetWidgetVisible(false, false); }
 
+  ui::SelectionBound::Type selection_bound_type() {
+    return selection_bound_.type();
+  }
+
   // Overridden from views::WidgetDelegateView:
   bool WidgetHasHitTestMask() const override { return true; }
 
   void GetWidgetHitTestMask(gfx::Path* mask) const override {
     gfx::Size image_size = image_->Size();
     mask->addRect(
         SkIntToScalar(0),
         SkIntToScalar(selection_bound_.GetHeight() +
                       kSelectionHandleVerticalVisualOffset),
         SkIntToScalar(image_size.width()) + 2 * kSelectionHandleHorizPadding,
@@ skipping 67 matching lines @@
       return;
     widget_->SetVisibilityAnimationDuration(
         base::TimeDelta::FromMilliseconds(
             quick ? kSelectionHandleQuickFadeDurationMs : 0));
     if (visible)
       widget_->Show();
     else
       widget_->Hide();
   }
 
-  void SetBoundInScreen(const ui::SelectionBound& bound) {
+  // If |is_visible| is true, this will update the widget and trigger a repaint
+  // if necessary. Otherwise this will only update the internal state:
+  // |selection_bound_| and |image_|, so that the state is valid for the time
+  // this becomes visible.
+  void SetBoundInScreen(const ui::SelectionBound& bound, bool is_visible) {
     bool update_bound_type = false;
     // Cursor handle should always have the bound type CENTER
     DCHECK(!is_cursor_handle_ || bound.type() == ui::SelectionBound::CENTER);
 
     if (bound.type() != selection_bound_.type()) {
       // Unless this is a cursor handle, do not set the type to CENTER -
       // selection handles corresponding to a selection should always use left
       // or right handle image. If selection handles are dragged to be located
       // at the same spot, the |bound|'s type here will be CENTER for both of
       // them. In this case do not update the type of the |selection_bound_|.
       if (bound.type() != ui::SelectionBound::CENTER || is_cursor_handle_)
         update_bound_type = true;
     }
     if (update_bound_type) {
       selection_bound_.set_type(bound.type());
       image_ = GetHandleImage(bound.type());
-      SchedulePaint();
+      if (is_visible)
+        SchedulePaint();
     }
+
+    if (!is_visible)
+      return;
+
     selection_bound_.SetEdge(bound.edge_top(), bound.edge_bottom());
 
     widget_->SetBounds(GetSelectionWidgetBounds(selection_bound_));
 
     aura::Window* window = widget_->GetNativeView();
     gfx::Point edge_top = selection_bound_.edge_top_rounded();
     gfx::Point edge_bottom = selection_bound_.edge_bottom_rounded();
     wm::ConvertPointFromScreen(window, &edge_top);
     wm::ConvertPointFromScreen(window, &edge_bottom);
     selection_bound_.SetEdge(gfx::PointF(edge_top), gfx::PointF(edge_bottom));
@@ skipping 117 matching lines @@
   }
 
   if (dragging_handle_) {
     // We need to reposition only the selection handle that is being dragged.
     // The other handle stays the same. Also, the selection handle being dragged
     // will always be at the end of selection, while the other handle will be at
     // the start.
     // If the new location of this handle is out of client view, its widget
     // should not get hidden, since it should still receive touch events.
     // Hence, we are not using |SetHandleBound()| method here.
-    dragging_handle_->SetBoundInScreen(screen_bound_focus_clipped);
+    dragging_handle_->SetBoundInScreen(screen_bound_focus_clipped, true);
 
     // Temporary fix for selection handle going outside a window. On a webpage,
     // the page should scroll if the selection handle is dragged outside the
     // window. That does not happen currently. So we just hide the handle for
     // now.
     // TODO(varunjain): Fix this: crbug.com/269003
     dragging_handle_->SetDrawInvisible(!ShouldShowHandleFor(focus));
 
     if (dragging_handle_ != cursor_handle_.get()) {
       // The non-dragging-handle might have recently become visible.
@@ skipping 79 matching lines @@
     EditingHandleView* source, gfx::Point* point) {
   View::ConvertPointToScreen(source, point);
   client_view_->ConvertPointFromScreen(point);
 }
 
 void TouchSelectionControllerImpl::SetHandleBound(
     EditingHandleView* handle,
     const ui::SelectionBound& bound,
     const ui::SelectionBound& bound_in_screen) {
   handle->SetWidgetVisible(ShouldShowHandleFor(bound), false);
-  if (handle->IsWidgetVisible())
-    handle->SetBoundInScreen(bound_in_screen);
+  handle->SetBoundInScreen(bound_in_screen, handle->IsWidgetVisible());
 }
 
 bool TouchSelectionControllerImpl::ShouldShowHandleFor(
     const ui::SelectionBound& bound) const {
   if (bound.GetHeight() < kSelectionHandleBarMinHeight)
     return false;
   gfx::Rect client_bounds = client_view_->GetBounds();
   client_bounds.Inset(0, 0, 0, -kSelectionHandleBarBottomAllowance);
   return client_bounds.Contains(BoundToRect(bound));
 }
@@ skipping 125 matching lines @@
   // by the same distance the handles are offset from the text.
   menu_anchor.Inset(0, -kSelectionHandleVerticalVisualOffset);
 
   return menu_anchor;
 }
 
 gfx::NativeView TouchSelectionControllerImpl::GetCursorHandleNativeView() {
   return cursor_handle_->GetWidget()->GetNativeView();
 }
 
+ui::SelectionBound::Type
+TouchSelectionControllerImpl::GetSelectionHandle1Type() {
+  return selection_handle_1_->selection_bound_type();
+}
+
 gfx::Rect TouchSelectionControllerImpl::GetSelectionHandle1Bounds() {
   return selection_handle_1_->GetBoundsInScreen();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetSelectionHandle2Bounds() {
   return selection_handle_2_->GetBoundsInScreen();
 }
 
 gfx::Rect TouchSelectionControllerImpl::GetCursorHandleBounds() {
   return cursor_handle_->GetBoundsInScreen();
@@ skipping 18 matching lines @@
 
 views::WidgetDelegateView* TouchSelectionControllerImpl::GetHandle1View() {
   return selection_handle_1_.get();
 }
 
 views::WidgetDelegateView* TouchSelectionControllerImpl::GetHandle2View() {
   return selection_handle_2_.get();
 }
 
 }  // namespace views