wip: Second crack at implementing the touch exploration mode.

ui/events/event_dispatcher.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/events/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "ui/events/event_target.h"
 #include "ui/events/event_targeter.h"
@@ skipping 27 matching lines @@
   if (dispatcher_)
     dispatcher_->OnDispatcherDelegateDestroyed();
 }
 
 Event* EventDispatcherDelegate::current_event() {
   return dispatcher_ ? dispatcher_->current_event() : NULL;
 }
 
 EventDispatchDetails EventDispatcherDelegate::DispatchEvent(EventTarget* target,
                                                             Event* event) {
+  LOG(ERROR) << "EventDispatcherDelegate::DispatchEvent 1"
+      << ", handled=" << event->handled();
   CHECK(target);
   Event::DispatcherApi dispatch_helper(event);
   dispatch_helper.set_phase(EP_PREDISPATCH);
   dispatch_helper.set_result(ER_UNHANDLED);
 
   EventDispatchDetails details = PreDispatchEvent(target, event);
+  LOG(ERROR) << "EventDispatcherDelegate::DispatchEvent: 2"
+      << ", handled=" << event->handled()
+      << ", details.dispatcher_destroyed=" << details.dispatcher_destroyed
+      << ", details.target_destroyed=" << details.target_destroyed;
   if (!event->handled() &&
       !details.dispatcher_destroyed &&
       !details.target_destroyed) {
     details = DispatchEventToTarget(target, event);
   }
   bool target_destroyed_during_dispatch = details.target_destroyed;
   if (!details.dispatcher_destroyed) {
     details = PostDispatchEvent(target_destroyed_during_dispatch ?
         NULL : target, *event);
   }
 
   details.target_destroyed |= target_destroyed_during_dispatch;
   return details;
 }
 
 EventDispatchDetails EventDispatcherDelegate::PreDispatchEvent(
     EventTarget* target, Event* event) {
   return EventDispatchDetails();
 }
 
 EventDispatchDetails EventDispatcherDelegate::PostDispatchEvent(
     EventTarget* target, const Event& event) {
   return EventDispatchDetails();
 }
 
 EventDispatchDetails EventDispatcherDelegate::DispatchEventToTarget(
     EventTarget* target,
     Event* event) {
+  LOG(ERROR) << "EventDispatcherDelegate::DispatchEventToTarget";
   EventDispatcher* old_dispatcher = dispatcher_;
   EventDispatcher dispatcher(this);
   dispatcher_ = &dispatcher;
   dispatcher.ProcessEvent(target, event);
   if (!dispatcher.delegate_destroyed())
     dispatcher_ = old_dispatcher;
   else if (old_dispatcher)
     old_dispatcher->OnDispatcherDelegateDestroyed();
 
   EventDispatchDetails details;
@@ skipping 14 matching lines @@
 EventDispatcher::~EventDispatcher() {
 }
 
 void EventDispatcher::OnHandlerDestroyed(EventHandler* handler) {
   handler_list_.erase(std::find(handler_list_.begin(),
                                 handler_list_.end(),
                                 handler));
 }
 
 void EventDispatcher::ProcessEvent(EventTarget* target, Event* event) {
+  LOG(ERROR) << "EventDispatcherDelegate::ProcessEvent";
   if (!target || !target->CanAcceptEvent(*event))
     return;
 
   ScopedDispatchHelper dispatch_helper(event);
   dispatch_helper.set_target(target);
 
   handler_list_.clear();
   target->GetPreTargetHandlers(&handler_list_);
 
   dispatch_helper.set_phase(EP_PRETARGET);
@@ skipping 59 matching lines @@
     return;
   }
 
   base::AutoReset<Event*> event_reset(&current_event_, event);
   handler->OnEvent(event);
   if (!delegate_ && event->cancelable())
     event->StopPropagation();
 }
 
 }  // namespace ui