Added PointerEvent firing on touch events.

Source/core/frame/EventHandlerRegistry.h

 // Copyright 2014 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.
 
 #ifndef EventHandlerRegistry_h
 #define EventHandlerRegistry_h
 
 #include "core/CoreExport.h"
 #include "core/frame/FrameHost.h"
 #include "wtf/HashCountedSet.h"
@@ skipping 12 matching lines @@
 public:
     explicit EventHandlerRegistry(FrameHost&);
     virtual ~EventHandlerRegistry();
 
     // Supported event handler classes. Note that each one may correspond to
     // multiple event types.
     enum EventHandlerClass {
         ScrollEvent,
         WheelEvent,
         TouchEvent,
+        PointerEvent,
 #if ENABLE(ASSERT)
         // Additional event categories for verifying handler tracking logic.
         EventsForTesting,
 #endif
         EventHandlerClassCount, // Must be the last entry.
     };
 
     // Returns true if the FrameHost has event handlers of the specified class.
     bool hasEventHandlers(EventHandlerClass) const;
 
@@ skipping 21 matching lines @@
     void clearWeakMembers(Visitor*);
 
 private:
     enum ChangeOperation {
         Add, // Add a new event handler.
         Remove, // Remove an existing event handler.
         RemoveAll // Remove any and all existing event handlers for a given target.
     };
 
     // Returns true if |eventType| belongs to a class this registry tracks.
     static bool eventTypeToClass(const AtomicString& eventType, EventHandlerClass* result);

[USE eero AT chromium.org, 2015/06/09 18:51:02]

You have not extended the eventTypeToClass function to handle also touch like
pointer events (such as pointerdown, pointermove, pointerup and pointercancel).

Due to that, if a document has PE handlers but not TE handlers, the renderer
thinks erroneously that touch events are not needed and does not pass them to
blink::EventHandler::handleTouchEvent, resulting in pointer events not to be
fired.

A simple fix is to modify the eventTypeToClass function to classify also touch
like pointer event types as TouchEvent types. After that, pointer event handlers
works.

A better fix might be to modify the eventTypeToClass function to classify touch
like pointer event types separately and to modify the EventHandlerRegistry class
and all other classes calling
EventHandlerRegistry::hasEventHandlers(EventHandlerRegistry::TouchEvent) to
consider a new TouchLikePointerEvent event handler class, too.
That would allow blink::EventHandler::handleTouchEvent to skip creation and
dispatching of TouchEvent or PointerEvent objects if there are no handlers for
touch events or touch like pointer events, respectively.

 
     // Returns true if the operation actually added a new target or completely
     // removed an existing one.
     bool updateEventHandlerTargets(ChangeOperation, EventHandlerClass, EventTarget*);
 
     // Called on the EventHandlerRegistry of the root Document to notify
     // clients when we have added the first handler or removed the last one for
     // a given event class. |hasActiveHandlers| can be used to distinguish
     // between the two cases.
     void notifyHasHandlersChanged(EventHandlerClass, bool hasActiveHandlers);
@@ skipping 13 matching lines @@
 
     void checkConsistency() const;
 
     FrameHost& m_frameHost;
     EventTargetSet m_targets[EventHandlerClassCount];
 };
 
 } // namespace blink
 
 #endif // EventHandlerRegistry_h