Refactors away method implementations in ui::EventTargeter

ui/views/test/event_generator_delegate_mac.mm

 // 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.
 
 #import <Cocoa/Cocoa.h>
 
 #import "base/mac/scoped_nsobject.h"
 #import "base/mac/scoped_objc_class_swizzler.h"
 #include "base/memory/singleton.h"
 #include "ui/events/event_processor.h"
@@ skipping 218 matching lines @@
 
   IMP CurrentEventMethod() {
     return swizzle_current_event_->GetOriginalImplementation();
   }
 
   NSWindow* window() { return window_.get(); }
   ui::test::EventGenerator* owner() { return owner_; }
 
   // Overridden from ui::EventTarget:
   bool CanAcceptEvent(const ui::Event& event) override { return true; }
-  ui::EventTarget* GetParentTarget() override { return NULL; }
+  ui::EventTarget* GetParentTarget() override { return nullptr; }
   scoped_ptr<ui::EventTargetIterator> GetChildIterator() const override;
   ui::EventTargeter* GetEventTargeter() override { return this; }
 
   // Overridden from ui::EventHandler (via ui::EventTarget):
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnTouchEvent(ui::TouchEvent* event) override;
 
   // Overridden from ui::EventSource:
   ui::EventProcessor* GetEventProcessor() override { return this; }
 
   // Overridden from ui::EventProcessor:
   ui::EventTarget* GetRootTarget() override { return this; }
 
   // Overridden from ui::EventDispatcherDelegate (via ui::EventProcessor):
   bool CanDispatchToTarget(EventTarget* target) override { return true; }
 
+  // Overridden from ui::EventTargeter:
+  ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
+                                      ui::Event* event) override {
+    return root;
+  }
+  ui::EventTarget* FindNextBestTarget(ui::EventTarget* previous_target,
+                                      ui::Event* event) override {
+    return nullptr;
+  }
+
   // Overridden from ui::test::EventGeneratorDelegate:
   void SetContext(ui::test::EventGenerator* owner,
                   gfx::NativeWindow root_window,
                   gfx::NativeWindow window) override;
   ui::EventTarget* GetTargetAt(const gfx::Point& location) override {
     return this;
   }
   ui::EventSource* GetEventSource(ui::EventTarget* target) override {
     return this;
   }
@@ skipping 16 matching lines @@
   ui::test::EventGenerator* owner_;
   base::scoped_nsobject<NSWindow> window_;
   scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_pressed_;
   scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_location_;
   scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_current_event_;
   base::scoped_nsobject<NSMenu> fake_menu_;
 
   DISALLOW_COPY_AND_ASSIGN(EventGeneratorDelegateMac);
 };
 
-EventGeneratorDelegateMac::EventGeneratorDelegateMac() : owner_(NULL) {
+EventGeneratorDelegateMac::EventGeneratorDelegateMac() : owner_(nullptr) {
   DCHECK(!ui::test::EventGenerator::default_delegate);
   ui::test::EventGenerator::default_delegate = this;
   // Install a fake "edit" menu. This is normally provided by Chrome's
   // MainMenu.xib, but src/ui shouldn't depend on that.
   fake_menu_.reset([[NSMenu alloc] initWithTitle:@"Edit"]);
   struct {
     NSString* title;
     SEL action;
     NSString* key_equivalent;
   } fake_menu_item[] = {
       {@"Undo", @selector(undo:), @"z"},
       {@"Redo", @selector(redo:), @"Z"},
       {@"Copy", @selector(copy:), @"c"},
       {@"Cut", @selector(cut:), @"x"},
       {@"Paste", @selector(paste:), @"v"},
       {@"Select All", @selector(selectAll:), @"a"},
   };
   for (size_t i = 0; i < arraysize(fake_menu_item); ++i) {
     [fake_menu_ insertItemWithTitle:fake_menu_item[i].title
                              action:fake_menu_item[i].action
                       keyEquivalent:fake_menu_item[i].key_equivalent
                             atIndex:i];
   }
 }
 
 EventGeneratorDelegateMac::~EventGeneratorDelegateMac() {
   DCHECK_EQ(this, ui::test::EventGenerator::default_delegate);
-  ui::test::EventGenerator::default_delegate = NULL;
+  ui::test::EventGenerator::default_delegate = nullptr;
 }
 
 scoped_ptr<ui::EventTargetIterator>
 EventGeneratorDelegateMac::GetChildIterator() const {
-  // Return NULL to dispatch all events to the result of GetRootTarget().
+  // Return nullptr to dispatch all events to the result of GetRootTarget().
   return nullptr;
 }
 
 void EventGeneratorDelegateMac::OnMouseEvent(ui::MouseEvent* event) {
   NSEvent* ns_event = CreateMouseEventInWindow(window_,
                                                event->type(),
                                                event->location(),
                                                event->changed_button_flags());
   if (owner_->targeting_application())
     [NSApp sendEvent:ns_event];
@@ skipping 126 matching lines @@
 - (NSEvent*)currentEvent {
   if (g_current_event)
     return g_current_event;
 
   // Find the original implementation and invoke it.
   IMP original = EventGeneratorDelegateMac::GetInstance()->CurrentEventMethod();
   return original(self, _cmd);
 }
 
 @end