Gets InputMethodFocus tests added in r327286 working on Mac

ui/views/widget/widget_interactive_uitest.cc

 // Copyright (c) 2013 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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/controls/textfield/textfield_test_api.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/test/focus_manager_test.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/touchui/touch_selection_controller_impl.h"
-#include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_delegate.h"
 #include "ui/wm/public/activation_client.h"
 
 #if defined(OS_WIN)
+#include "ui/aura/window.h"
+#include "ui/aura/window_tree_host.h"
+#include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/win/hwnd_util.h"
-#elif defined(USE_X11)
-#include "ui/base/x/x11_util.h"
-#include "ui/views/test/x11_property_change_waiter.h"
 #endif
 
 namespace views {
 namespace test {
 
 namespace {
 
 // A View that closes the Widget and exits the current message-loop when it
 // receives a mouse-release event.
 class ExitLoopOnRelease : public View {
@@ skipping 99 matching lines @@
 
   Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(NestedLoopCaptureView);
 };
 
 // Spins a run loop until a Widget's active state matches a desired state.
 class WidgetActivationWaiter : public WidgetObserver {
  public:
   WidgetActivationWaiter(Widget* widget, bool active) : observed_(false) {
+#if defined(OS_WIN)
+    // On Windows, a HWND can receive a WM_ACTIVATE message without the value
+    // of ::GetActiveWindow() updating to reflect that change. This can cause
+    // the active window reported by IsActive() to get out of sync. Usually this
+    // happens after a call to HWNDMessageHandler::Deactivate() which works by
+    // activating some other window, which might be in another application.
+    // Doing this can trigger the native OS activation-blocker, causing the
+    // taskbar icon to flash instead. But since activation of native widgets on
+    // Windows is synchronous, we never have to wait anyway, so it's safe to
+    // return here.
+    if (active == widget->IsActive()) {
+      observed_ = true;
+      return;
+    }
+#endif
     // Always expect a change for tests using this.
     EXPECT_NE(active, widget->IsActive());
     widget->AddObserver(this);
   }
 
   void Wait() {
     if (!observed_)
       run_loop_.Run();
   }
 
   void OnWidgetActivationChanged(Widget* widget, bool active) override {
     observed_ = true;
     widget->RemoveObserver(this);
     if (run_loop_.running())
       run_loop_.Quit();
   }
 
  private:
   base::RunLoop run_loop_;
   bool observed_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetActivationWaiter);
 };
 
-#if defined(USE_X11)
-class WidgetActivationWaiterX11 : public X11PropertyChangeWaiter {
- public:
-  explicit WidgetActivationWaiterX11(Widget* widget, bool active)
-      : X11PropertyChangeWaiter(ui::GetX11RootWindow(), "_NET_ACTIVE_WINDOW"),
-        window_(widget->GetNativeWindow()->GetHost()->GetAcceleratedWidget()) {
-    EXPECT_NE(active, widget->IsActive());
-  }
-
-  ~WidgetActivationWaiterX11() override {}
-
- private:
-  // X11PropertyChangeWaiter:
-  bool ShouldKeepOnWaiting(const ui::PlatformEvent& event) override {
-    XID xid = 0;
-    ui::GetXIDProperty(ui::GetX11RootWindow(), "_NET_ACTIVE_WINDOW", &xid);
-    return xid != window_;
-  }
-
-  XID window_;
-
-  DISALLOW_COPY_AND_ASSIGN(WidgetActivationWaiterX11);
-};
-#endif
-
 ui::WindowShowState GetWidgetShowState(const Widget* widget) {
   // Use IsMaximized/IsMinimized/IsFullScreen instead of GetWindowPlacement
   // because the former is implemented on all platforms but the latter is not.
   return widget->IsFullscreen() ? ui::SHOW_STATE_FULLSCREEN :
       widget->IsMaximized() ? ui::SHOW_STATE_MAXIMIZED :
       widget->IsMinimized() ? ui::SHOW_STATE_MINIMIZED :
       widget->IsActive() ? ui::SHOW_STATE_NORMAL :
                            ui::SHOW_STATE_INACTIVE;
 }
 
@@ skipping 19 matching lines @@
 }
 
 // Like for ActivateSync(), wait for a widget to become active, but Show() the
 // widget rather than calling Activate().
 void ShowSync(Widget* widget) {
   WidgetActivationWaiter waiter(widget, true);
   widget->Show();
   waiter.Wait();
 }
 
-#if defined(USE_AURA)
-void ActivatePlatformWindowSync(Widget* widget) {
+void DeactivateSync(Widget* widget) {
+#if defined(OS_MACOSX)
+  // Deactivation of a window isn't a concept on Mac: If an application is
+  // active and it has any activatable windows, then one of them is always
+  // active. But we can simulate deactivation (e.g. as if another application
+  // became active) by temporarily making |widget| non-activatable, then
+  // activating (and closing) a temporary widget.
+  widget->widget_delegate()->set_can_activate(false);
+  Widget* stealer = new Widget;
+  stealer->Init(Widget::InitParams(Widget::InitParams::TYPE_WINDOW));
+  ShowSync(stealer);
+  stealer->CloseNow();
+  widget->widget_delegate()->set_can_activate(true);

[tapted, 2015/05/05 00:31:41]

Unfortunately, this approach doesn't work on Windows -- I don't think we can
prevent the OS from setting a foreground window the way we can on Mac, so
::GetForegroundWindow() will just update back to the window we're trying to
deactivate unless the window sticks around (which is done for Windows in the
WidgetInputMethodInteractiveTest harness below).

+#else
+  WidgetActivationWaiter waiter(widget, false);
+  widget->Deactivate();
+  waiter.Wait();
+#endif
+}
+
 #if defined(OS_WIN)
+void ActivatePlatformWindow(Widget* widget) {
   ::SetActiveWindow(
       widget->GetNativeWindow()->GetHost()->GetAcceleratedWidget());
-#elif defined(OS_CHROMEOS)
-  widget->Activate();
-#elif defined(USE_X11)
-  if (!widget->IsActive()) {
-    WidgetActivationWaiterX11 waiter(widget, true);
-    widget->Activate();
-    waiter.Wait();
-  }
-#else
-  ActivateSync(widget);
-#endif
 }
 #endif
 
 // Calls ShowInactive() on a Widget, and spins a run loop. The goal is to give
 // the OS a chance to activate a widget. However, for this case, the test
 // doesn't expect that to happen, so there is nothing to wait for.
 void ShowInactiveSync(Widget* widget) {
   widget->ShowInactive();
   RunPendingMessagesForActiveStatusChange();
 }
@@ skipping 25 matching lines @@
       controller->ContextMenuTimerFired();
 #endif
     }
   }
 
   static bool IsQuickMenuVisible(TouchSelectionControllerImpl* controller) {
     DCHECK(controller);
     return controller->context_menu_ && controller->context_menu_->visible();
   }
 
-  scoped_ptr<Widget> CreateWidget() {
-#if !defined(USE_AURA)
-    return NULL;
-#else
-    scoped_ptr<Widget> widget(new Widget);
-    Widget::InitParams params =
-        CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
-    params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-    params.bounds = gfx::Rect(0, 0, 200, 200);
-#if defined(OS_CHROMEOS)
-    params.native_widget = NULL;
-#else
-    params.native_widget = new DesktopNativeWidgetAura(widget.get());
-#endif
-    widget->Init(params);
-    return widget.Pass();
-#endif
+  Widget* CreateWidget() {
+    Widget* widget = CreateNativeDesktopWidget();
+    widget->SetBounds(gfx::Rect(0, 0, 200, 200));
+    return widget;
   }
 };
 
 #if defined(OS_WIN)
 // Tests whether activation and focus change works correctly in Windows.
 // We test the following:-
 // 1. If the active aura window is correctly set when a top level widget is
 //    created.
 // 2. If the active aura window in widget 1 created above, is set to NULL when
 //    another top level widget is created and focused.
 // 3. On focusing the native platform window for widget 1, the active aura
 //    window for widget 1 should be set and that for widget 2 should reset.
 // TODO(ananta): Discuss with erg on how to write this test for linux x11 aura.
 TEST_F(WidgetTestInteractive, DesktopNativeWidgetAuraActivationAndFocusTest) {
   // Create widget 1 and expect the active window to be its window.
-  View* contents_view1 = new View;
-  contents_view1->SetFocusable(true);
-  scoped_ptr<Widget> widget1(CreateWidget());
-  widget1->SetContentsView(contents_view1);
+  View* focusable_view1 = new View;
+  focusable_view1->SetFocusable(true);
+  Widget* widget1 = CreateWidget();
+  widget1->GetContentsView()->AddChildView(focusable_view1);
   widget1->Show();
-  aura::Window* root_window1= widget1->GetNativeView()->GetRootWindow();
-  contents_view1->RequestFocus();
+  aura::Window* root_window1 = widget1->GetNativeView()->GetRootWindow();
+  focusable_view1->RequestFocus();
 
   EXPECT_TRUE(root_window1 != NULL);
   aura::client::ActivationClient* activation_client1 =
       aura::client::GetActivationClient(root_window1);
   EXPECT_TRUE(activation_client1 != NULL);
   EXPECT_EQ(activation_client1->GetActiveWindow(), widget1->GetNativeView());
 
   // Create widget 2 and expect the active window to be its window.
-  View* contents_view2 = new View;
-  scoped_ptr<Widget> widget2(CreateWidget());
-  widget2->SetContentsView(contents_view2);
+  View* focusable_view2 = new View;
+  Widget* widget2 = CreateWidget();
+  widget1->GetContentsView()->AddChildView(focusable_view2);
   widget2->Show();
   aura::Window* root_window2 = widget2->GetNativeView()->GetRootWindow();
-  contents_view2->RequestFocus();
-  ActivatePlatformWindowSync(widget2.get());
+  focusable_view2->RequestFocus();
+  ActivatePlatformWindow(widget2);
 
   aura::client::ActivationClient* activation_client2 =
       aura::client::GetActivationClient(root_window2);
   EXPECT_TRUE(activation_client2 != NULL);
   EXPECT_EQ(activation_client2->GetActiveWindow(), widget2->GetNativeView());
   EXPECT_EQ(activation_client1->GetActiveWindow(),
             reinterpret_cast<aura::Window*>(NULL));
 
   // Now set focus back to widget 1 and expect the active window to be its
   // window.
-  contents_view1->RequestFocus();
-  ActivatePlatformWindowSync(widget1.get());
+  focusable_view1->RequestFocus();
+  ActivatePlatformWindow(widget1);
   EXPECT_EQ(activation_client2->GetActiveWindow(),
             reinterpret_cast<aura::Window*>(NULL));
   EXPECT_EQ(activation_client1->GetActiveWindow(), widget1->GetNativeView());
+
+  widget2->CloseNow();
+  widget1->CloseNow();
 }
 #endif  // defined(OS_WIN)
 
 TEST_F(WidgetTestInteractive, CaptureAutoReset) {
   Widget* toplevel = CreateTopLevelFramelessPlatformWidget();
   View* container = new View;
   toplevel->SetContentsView(container);
 
   EXPECT_FALSE(toplevel->HasCapture());
   toplevel->SetCapture(NULL);
@@ skipping 531 matching lines @@
 #endif
 
 // Test that touch selection quick menu is not activated when opened.
 TEST_F(WidgetTestInteractive, MAYBE_TouchSelectionQuickMenuIsNotActivated) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchEditing);
 #if defined(OS_WIN)
   views_delegate().set_use_desktop_native_widgets(true);
 #endif  // !defined(OS_WIN)
 
-  scoped_ptr<Widget> widget(CreateWidget());
+  Widget* widget = CreateWidget();
 
   Textfield* textfield = new Textfield;
   textfield->SetBounds(0, 0, 200, 20);
   textfield->SetText(base::ASCIIToUTF16("some text"));
   widget->GetRootView()->AddChildView(textfield);
 
   widget->Show();
   textfield->RequestFocus();
   textfield->SelectAll(true);
   TextfieldTestApi textfield_test_api(textfield);
 
   RunPendingMessages();
 
   ui::test::EventGenerator generator(widget->GetNativeWindow());
   generator.GestureTapAt(gfx::Point(10, 10));
   ShowQuickMenuImmediately(static_cast<TouchSelectionControllerImpl*>(
       textfield_test_api.touch_selection_controller()));
 
   EXPECT_TRUE(textfield->HasFocus());
   EXPECT_TRUE(widget->IsActive());
   EXPECT_TRUE(IsQuickMenuVisible(static_cast<TouchSelectionControllerImpl*>(
       textfield_test_api.touch_selection_controller())));
+  widget->CloseNow();
 }
 
 TEST_F(WidgetTestInteractive, DisableViewDoesNotActivateWidget) {
 #if defined(OS_WIN)
   views_delegate().set_use_desktop_native_widgets(true);
 #endif  // !defined(OS_WIN)
 
   // Create first widget and view, activate the widget, and focus the view.
   Widget widget1;
   Widget::InitParams params1 = CreateParams(Widget::InitParams::TYPE_POPUP);
@@ skipping 485 matching lines @@
   ui::MouseEvent mouse_event(ui::ET_MOUSE_EXITED, gfx::Point(), gfx::Point(),
                              ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
   ui::EventDispatchDetails details = widget1.GetNativeWindow()->
       GetHost()->event_processor()->OnEventFromSource(&mouse_event);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(widget1.GetAndClearGotMouseEvent());
   EXPECT_FALSE(widget2.GetAndClearGotMouseEvent());
 }
 #endif  // defined(OS_WIN)
 
-#if defined(USE_AURA)
+class WidgetInputMethodInteractiveTest : public WidgetTestInteractive {
+ public:
+  WidgetInputMethodInteractiveTest() {}
+
+  // testing::Test:
+  void SetUp() override {
+    WidgetTestInteractive::SetUp();
+#if defined(OS_WIN)
+    // On Windows, Widget::Deactivate() works by activating the next topmost
+    // window on the z-order stack. This only works if there is at least one
+    // other window, so make sure that is the case.
+    deactivate_widget_ = CreateWidget();
+    deactivate_widget_->Show();
+#endif
+  }
+
+  void TearDown() override {
+    if (deactivate_widget_)
+      deactivate_widget_->CloseNow();
+    WidgetTestInteractive::TearDown();
+  }
+
+ private:
+  Widget* deactivate_widget_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(WidgetInputMethodInteractiveTest);
+};
+
 // Test input method focus changes affected by top window activaction.
-TEST_F(WidgetTestInteractive, InputMethodFocus_activation) {
-  scoped_ptr<Widget> widget(CreateWidget());
-  scoped_ptr<Textfield> textfield(new Textfield);
-  widget->GetRootView()->AddChildView(textfield.get());
-  widget->Show();
+TEST_F(WidgetInputMethodInteractiveTest, Activation) {
+  Widget* widget = CreateWidget();
+  Textfield* textfield = new Textfield;
+  widget->GetRootView()->AddChildView(textfield);
   textfield->RequestFocus();
 
-  ActivatePlatformWindowSync(widget.get());
+  ShowSync(widget);
 
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             widget->GetInputMethod()->GetTextInputType());
 
-  widget->Deactivate();
+  DeactivateSync(widget);
 
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget->GetInputMethod()->GetTextInputType());
+  widget->CloseNow();
 }
 
 // Test input method focus changes affected by focus changes within 1 window.
-TEST_F(WidgetTestInteractive, InputMethodFocus_1_window) {
-  scoped_ptr<Widget> widget(CreateWidget());
-  scoped_ptr<Textfield> textfield1(new Textfield);
-  scoped_ptr<Textfield> textfield2(new Textfield);
+TEST_F(WidgetInputMethodInteractiveTest, OneWindow) {
+  Widget* widget = CreateWidget();
+  Textfield* textfield1 = new Textfield;
+  Textfield* textfield2 = new Textfield;
   textfield2->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  widget->GetRootView()->AddChildView(textfield1.get());
-  widget->GetRootView()->AddChildView(textfield2.get());
-  widget->Show();
+  widget->GetRootView()->AddChildView(textfield1);
+  widget->GetRootView()->AddChildView(textfield2);
 
-  ActivatePlatformWindowSync(widget.get());
+  ShowSync(widget);
 
   textfield1->RequestFocus();
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             widget->GetInputMethod()->GetTextInputType());
 
   textfield2->RequestFocus();
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD,
             widget->GetInputMethod()->GetTextInputType());
 
 // Window::Blur doesn't work for CrOS, because it uses NWA instead of DNWA and
 // involves the AuraTestHelper which setup the input method as DummyInputMethod.
 // Please refer to CreateWidget method above.
 #if !defined(OS_CHROMEOS)
-  aura::Window* window = widget->GetNativeWindow();
-  window->Blur();
+  DeactivateSync(widget);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget->GetInputMethod()->GetTextInputType());
 
-  window->Focus();
+  ActivateSync(widget);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD,
             widget->GetInputMethod()->GetTextInputType());
 
-  window->Blur();
+  DeactivateSync(widget);
   textfield1->RequestFocus();
-  window->Focus();
-  EXPECT_TRUE(window->HasFocus());
+  ActivateSync(widget);
+  EXPECT_TRUE(widget->IsActive());
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             widget->GetInputMethod()->GetTextInputType());
 #endif
+  widget->CloseNow();
 }
 
 // Test input method focus changes affected by focus changes cross 2 windows
 // which shares the same top window.
-TEST_F(WidgetTestInteractive, InputMethodFocus_2_windows) {
-  scoped_ptr<Widget> widget(CreateWidget());
-  widget->Show();
+TEST_F(WidgetInputMethodInteractiveTest, TwoWindows) {
+  Widget* parent = CreateWidget();
+  parent->SetBounds(gfx::Rect(100, 100, 100, 100));
 
-  views::View* parent_root = new View;
-  scoped_ptr<Widget> parent(new Widget);
-  Widget::InitParams parent_params(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
-  parent_params.ownership =
-      views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  parent_params.context = widget->GetNativeWindow();
-  parent->Init(parent_params);
-  parent->SetContentsView(parent_root);
-  parent->SetBounds(gfx::Rect(100, 100, 100, 100));
-  parent->Show();
-
-  scoped_ptr<Widget> child(new Widget());
-  Widget::InitParams child_params(Widget::InitParams::TYPE_CONTROL);
-  child_params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  child_params.parent = parent->GetNativeWindow();
-  child->Init(child_params);
+  Widget* child = CreateChildNativeWidgetWithParent(parent);
   child->SetBounds(gfx::Rect(0, 0, 50, 50));
   child->Show();
 
-  scoped_ptr<Textfield> textfield_parent(new Textfield);
-  scoped_ptr<Textfield> textfield_child(new Textfield);
+  Textfield* textfield_parent = new Textfield;
+  Textfield* textfield_child = new Textfield;
   textfield_parent->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  parent->GetRootView()->AddChildView(textfield_parent.get());
-  child->GetRootView()->AddChildView(textfield_child.get());
+  parent->GetRootView()->AddChildView(textfield_parent);
+  child->GetRootView()->AddChildView(textfield_child);
+  ShowSync(parent);
 
   EXPECT_EQ(parent->GetInputMethod(), child->GetInputMethod());
 
   textfield_parent->RequestFocus();
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD,
             parent->GetInputMethod()->GetTextInputType());
 
   textfield_child->RequestFocus();
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             parent->GetInputMethod()->GetTextInputType());
 
 // Window::Blur doesn't work for CrOS, because it uses NWA instead of DNWA and

[Shu Chen, 2015/05/05 02:37:06]

Please update the comment, actually Window::Blur will not be used in the
following code.

[tapted, 2015/05/05 06:38:30]

Done.

 // involves the AuraTestHelper which setup the input method as DummyInputMethod.
 // Please refer to CreateWidget method above.
 #if !defined(OS_CHROMEOS)
-  child->GetNativeWindow()->Blur();
+  DeactivateSync(parent);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             parent->GetInputMethod()->GetTextInputType());
 
-  child->GetNativeWindow()->Focus();
+  ActivateSync(parent);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             parent->GetInputMethod()->GetTextInputType());
 
   textfield_parent->RequestFocus();
-  parent->GetNativeWindow()->Blur();
+  DeactivateSync(parent);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             parent->GetInputMethod()->GetTextInputType());
 
-  parent->GetNativeWindow()->Focus();
+  ActivateSync(parent);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD,
             parent->GetInputMethod()->GetTextInputType());
 #endif
+
+  parent->CloseNow();
 }
 
 // Test input method focus changes affected by focus changes cross 2 top
 // windows.
-TEST_F(WidgetTestInteractive, InputMethodFocus_2_top_windows) {
-  scoped_ptr<Widget> widget1(CreateWidget());
-  scoped_ptr<Widget> widget2(CreateWidget());
-  scoped_ptr<Textfield> textfield1(new Textfield);
-  scoped_ptr<Textfield> textfield2(new Textfield);
+TEST_F(WidgetInputMethodInteractiveTest, TwoTopWindows) {
+  Widget* widget1 = CreateWidget();
+  Widget* widget2 = CreateWidget();
+  Textfield* textfield1 = new Textfield;
+  Textfield* textfield2 = new Textfield;
   textfield2->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  widget1->GetRootView()->AddChildView(textfield1.get());
-  widget2->GetRootView()->AddChildView(textfield2.get());
+  widget1->GetRootView()->AddChildView(textfield1);
+  widget2->GetRootView()->AddChildView(textfield2);
   widget1->Show();
   widget2->Show();
 
   textfield1->RequestFocus();
   textfield2->RequestFocus();
 
-  ActivatePlatformWindowSync(widget1.get());
+  ActivateSync(widget1);
 
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             widget1->GetInputMethod()->GetTextInputType());
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget2->GetInputMethod()->GetTextInputType());
 
-  ActivatePlatformWindowSync(widget2.get());
+  ActivateSync(widget2);
 
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget1->GetInputMethod()->GetTextInputType());
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD,
             widget2->GetInputMethod()->GetTextInputType());
+
+  widget2->CloseNow();
+  widget1->CloseNow();
 }
 
 // Test input method focus changes affected by textfield's state changes.
-TEST_F(WidgetTestInteractive, InputMethodFocus_textfield) {
-  scoped_ptr<Widget> widget(CreateWidget());
-  scoped_ptr<Textfield> textfield(new Textfield);
-  widget->GetRootView()->AddChildView(textfield.get());
-  widget->Show();
-  ActivatePlatformWindowSync(widget.get());
+TEST_F(WidgetInputMethodInteractiveTest, TextField) {
+  Widget* widget = CreateWidget();
+  Textfield* textfield = new Textfield;
+  widget->GetRootView()->AddChildView(textfield);
+  ShowSync(widget);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget->GetInputMethod()->GetTextInputType());
 
   textfield->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget->GetInputMethod()->GetTextInputType());
 
   textfield->RequestFocus();
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_PASSWORD,
             widget->GetInputMethod()->GetTextInputType());
 
   textfield->SetTextInputType(ui::TEXT_INPUT_TYPE_TEXT);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_TEXT,
             widget->GetInputMethod()->GetTextInputType());
 
   textfield->SetReadOnly(true);
   EXPECT_EQ(ui::TEXT_INPUT_TYPE_NONE,
             widget->GetInputMethod()->GetTextInputType());
+  widget->CloseNow();
 }
-#endif  // defined(USE_AURA)
 
 }  // namespace test
 }  // namespace views