touch: Return an enum from OnTouchEvent.

chrome/browser/renderer_host/render_widget_host_view_views.cc

 // Copyright (c) 2010 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 "chrome/browser/renderer_host/render_widget_host_view_views.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/l10n_util.h"
@@ skipping 716 matching lines @@
   host_->ForwardTouchEvent(touch_event_);
 
   // If the touch was released, then remove it from the list of touch points.
   if (e.GetType() == views::Event::ET_TOUCH_RELEASED) {
     --touch_event_.touchPointsLength;
     for (int i = point - touch_event_.touchPoints;
          i < touch_event_.touchPointsLength;
          ++i) {
       touch_event_.touchPoints[i] = touch_event_.touchPoints[i + 1];
     }
+
+    if (touch_event_.touchPointsLength == 0) {

[sky, 2011/01/14 21:47:20]

This pattern is much different from how we've typically done processing like
this.

Can OnTouchSequenceEnd be a real method on View (like OnTouchEvent), and have
whoever invokes OnTouchEvent be responsible for invoking OnTouchSequenceEnd?

[sadrul, 2011/01/14 22:11:33]

I think you mean that the RootView, or the AcceleratorHandler (which reads the
touch-event from X) should invoke OnTouchSequenceEnd?

Currently, the list of touch points are maintained by the
RenderWidgetHostViewViews (RWHVV). The RootView (RV) receives a views
touch-event (e.g. a touch-point press, or a touch-point move etc.) from
AcceleratorHandler (AH) and dispatches it down the views hierarchy to the RWHVV.
Upon receiving the event, the RWHVV updates the webkit touchevent it maintains,
and sends it off to the renderer. It is not possible for the RV (or AH) to
recognize the end of a touch sequence (because, e.g. a touch-point release may
not be the end of the sequence because other points remain pressed). So it is
necessary for the RWHVV to notify the RV that the touch-sequence has ended. This
allows the RV to reset the touch-event-handler, so that subsequent touch-events
can be sent to the correct view, instead of sending all touch-events to the view
that received the very first touch-event.

An alternate solution considered was for the RWHVV to send a TOUCH_END event to
the RV (using OnTouchEvent). But the reversed direction of the message (RWHVV ->
RV, instead of the usual RV -> RWHVV) felt a bit unclean.

Another alternate solution considered was to maintain the list of touch-points
in RV (or somewhere in views, e.g. a singleton TouchFactory). However, in this
approach, for each event from each views-touch-point, the RWHVV will need to
update the state for each webkit-touch-point before sending it off to the
renderer. This may have a significant effect on multi-touch performance.

Did I make sense? Please let me know if what I said needs farther
explanation/clarification.

+      // A touch sequence has completely ended. Notify the observer.
+      if (touch_event_observer_) {
+        touch_event_observer_->OnTouchSequenceEnd();
+      }
+    }
   }
 
   return true;
 }
 
 // static
 RenderWidgetHostView*
     RenderWidgetHostView::GetRenderWidgetHostViewFromNativeView(
         gfx::NativeView widget) {
   gpointer user_data = g_object_get_data(G_OBJECT(widget),
                                          kRenderWidgetHostViewKey);
   return reinterpret_cast<RenderWidgetHostView*>(user_data);
 }