MacViews: Implement Full Keyboard Access.

ui/base/test/scoped_fake_nswindow_focus.mm

 // Copyright 2015 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 "ui/base/test/scoped_fake_nswindow_focus.h"
 
 #import <Cocoa/Cocoa.h>
 
 #import "base/mac/foundation_util.h"
 #import "base/mac/scoped_objc_class_swizzler.h"
 
 using base::mac::ScopedObjCClassSwizzler;
 
 namespace {
 
 NSWindow* g_fake_focused_window = nil;
+IMP g_order_out_impl_ = nullptr;
 
 void SetFocus(NSWindow* window) {
   g_fake_focused_window = window;
   [[NSNotificationCenter defaultCenter]
       postNotificationName:NSWindowDidBecomeMainNotification
                     object:g_fake_focused_window];
   [[NSNotificationCenter defaultCenter]
       postNotificationName:NSWindowDidBecomeKeyNotification
                     object:g_fake_focused_window];
 }
@@ skipping 35 matching lines @@
     return;
 
   ClearFocus();
   SetFocus(selfAsWindow);
 }
 
 - (void)makeMainWindow {
   [self makeKeyWindow];
 }
 
+- (void)orderOut:(id)sender {

[tapted, 2016/04/20 06:05:57]

What tests ended up needing this? It doesn't seem right to swizzle just orderOut
-- there are too many ways of making a window hidden/visible on Mac -- e.g.
there's `-[NSWindow orderWindow:NSWindowOut relateiveTo:nil]`. And ther should
maybe be a balanced orderIn.

Is there a way to resolve the problem by watching for -resignKeyWindow instead? 
(in theory, all the native OrderOut methods should be invoking that)

And if it's just for an added test (e.g.
BridgedNativeWidgetFullKeyboardAccess.something), we might want to restrict the
swizzling just to those tests, or just provide a way to call `ClearFocus`
explicitly via the ScopedFakeNSWindowFocus public API

[karandeepb, 2016/05/03 02:54:12]

I needed this for NativeWidgetMacFullKeyboardAccessTest.Activation. I had tried 
swizzling -resignKeyWindow, but it's not being invoked. I guess this is expected
because the window is not actually key, since we are swizzling makeKeyWindow: 
and isKeyWindow:.

Still I think this is a good change if we can't find any other way to track the 
"unfocusing" of a window because- 
1) Since we are not swizzling any "unfocusing" methods currently, 
g_fake_focused_window is not completely correct. Hence if we do 
  widget->Show()
  widget->Hide()
g_fake_focused_window will still point to widget's window. Hence if we do a
Show() again, it will be ignored.

2) [window close] also calls orderOut. 

3) Current implementation can lead to subtle bugs. For example, if the currently
focused window is destroyed(say by invoking close), and then
ScopedFakeNSWindowFocus is
destroyed, it will cause an invalid memory reference, since
g_fake_focused_window
points to a destroyed window. Hence we have to be careful about destruction
sequence currently.

4) This still calls the original orderOut implementation, so I don't see this as
having any adverse effects.

Also, this will help generate windowDidResignKey notifications on widget->Hide()
which is not the case currently.

[tapted, 2016/05/03 08:08:25]

OK sounds good. That's lots of reasons :). For a test-helper, I guess it's OK
that there may be limitations, and this is leading to fewer limitations. (E.g.
[NSApp hide] probably doesn't call orderOut, but in a real app it should call
resignKeyWindow)

[karandeepb, 2016/05/04 01:56:38]

Hehe yeah :) I realized that after writing this!

+  NSWindow* selfAsWindow = base::mac::ObjCCastStrict<NSWindow>(self);
+  if (selfAsWindow == g_fake_focused_window)
+    g_fake_focused_window = nil;
+  g_order_out_impl_(self, _cmd, sender);
+}
+
 @end
 
 namespace ui {
 namespace test {
 
 ScopedFakeNSWindowFocus::ScopedFakeNSWindowFocus()
     : is_main_swizzler_(
           new ScopedObjCClassSwizzler([NSWindow class],
                                       [FakeNSWindowFocusDonor class],
                                       @selector(isMainWindow))),
       make_main_swizzler_(
           new ScopedObjCClassSwizzler([NSWindow class],
                                       [FakeNSWindowFocusDonor class],
                                       @selector(makeMainWindow))),
       is_key_swizzler_(
           new ScopedObjCClassSwizzler([NSWindow class],
                                       [FakeNSWindowFocusDonor class],
                                       @selector(isKeyWindow))),
       make_key_swizzler_(
           new ScopedObjCClassSwizzler([NSWindow class],
                                       [FakeNSWindowFocusDonor class],
-                                      @selector(makeKeyWindow))) {}
+                                      @selector(makeKeyWindow))),
+      order_out_swizzler_(
+          new ScopedObjCClassSwizzler([NSWindow class],
+                                      [FakeNSWindowFocusDonor class],
+                                      @selector(orderOut:))) {
+  g_order_out_impl_ = order_out_swizzler_->GetOriginalImplementation();
+}
 
 ScopedFakeNSWindowFocus::~ScopedFakeNSWindowFocus() {
   ClearFocus();
 }
 
 }  // namespace test
 }  // namespace ui