path: root/chromium/ui/views/focus/focus_manager_unittest_win.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/views/focus/focus_manager.h"

#include "base/memory/scoped_ptr.h"
#include "base/run_loop.h"
#include "base/strings/utf_string_conversions.h"
#include "ui/events/event.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/focus/accelerator_handler.h"
#include "ui/views/focus/focus_manager_test.h"
#include "ui/views/widget/widget.h"

namespace views {

namespace {

class MessageTrackingView : public View {
 public:
  MessageTrackingView() : accelerator_pressed_(false) {
  }

  void Reset() {
    accelerator_pressed_ = false;
    keys_pressed_.clear();
    keys_released_.clear();
  }

  const std::vector<ui::KeyboardCode>& keys_pressed() const {
    return keys_pressed_;
  }

  const std::vector<ui::KeyboardCode>& keys_released() const {
    return keys_released_;
  }

  bool accelerator_pressed() const {
    return accelerator_pressed_;
  }

  // Overridden from View:
  virtual bool OnKeyPressed(const ui::KeyEvent& e) OVERRIDE {
    keys_pressed_.push_back(e.key_code());
    return true;
  }
  virtual bool OnKeyReleased(const ui::KeyEvent& e) OVERRIDE {
    keys_released_.push_back(e.key_code());
    return true;
  }
  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE {
    accelerator_pressed_ = true;
    return true;
  }

 private:
  bool accelerator_pressed_;
  std::vector<ui::KeyboardCode> keys_pressed_;
  std::vector<ui::KeyboardCode> keys_released_;

  DISALLOW_COPY_AND_ASSIGN(MessageTrackingView);
};

}  // namespace

// Test that when activating/deactivating the top window, the focus is stored/
// restored properly.
TEST_F(FocusManagerTest, FocusStoreRestore) {
  // Simulate an activate, otherwise the deactivate isn't going to do anything.
  SimulateActivateWindow();

  LabelButton* button = new LabelButton(NULL, ASCIIToUTF16("Press me"));
  button->SetStyle(Button::STYLE_NATIVE_TEXTBUTTON);
  View* view = new View();
  view->SetFocusable(true);

  GetContentsView()->AddChildView(button);
  button->SetBounds(10, 10, 200, 30);
  GetContentsView()->AddChildView(view);
  RunPendingMessages();

  TestFocusChangeListener listener;
  AddFocusChangeListener(&listener);

  view->RequestFocus();
  RunPendingMessages();

  // Required for VS2010: http://connect.microsoft.com/VisualStudio/feedback/details/520043/error-converting-from-null-to-a-pointer-type-in-std-pair
  views::View* null_view = NULL;

  // Deacivate the window, it should store its focus.
  SimulateDeactivateWindow();
  EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView());
  ASSERT_EQ(2, static_cast<int>(listener.focus_changes().size()));
  EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(null_view, view));
  EXPECT_TRUE(listener.focus_changes()[1] == ViewPair(view, null_view));
  listener.ClearFocusChanges();

  // Reactivate, focus should come-back to the previously focused view.
  SimulateActivateWindow();
  EXPECT_EQ(view, GetFocusManager()->GetFocusedView());
  ASSERT_EQ(1, static_cast<int>(listener.focus_changes().size()));
  EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(null_view, view));
  listener.ClearFocusChanges();

  // Same test with a NativeControl.
  button->RequestFocus();
  SimulateDeactivateWindow();
  EXPECT_EQ(NULL, GetFocusManager()->GetFocusedView());
  ASSERT_EQ(2, static_cast<int>(listener.focus_changes().size()));
  EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(view, button));
  EXPECT_TRUE(listener.focus_changes()[1] == ViewPair(button, null_view));
  listener.ClearFocusChanges();

  SimulateActivateWindow();
  EXPECT_EQ(button, GetFocusManager()->GetFocusedView());
  ASSERT_EQ(1, static_cast<int>(listener.focus_changes().size()));
  EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(null_view, button));
  listener.ClearFocusChanges();

  /*
  // Now test that while the window is inactive we can change the focused view
  // (we do that in several places).
  SimulateDeactivateWindow();
  // TODO: would have to mock the window being inactive (with a TestWidgetWin
  //       that would return false on IsActive()).
  GetFocusManager()->SetFocusedView(view);
  ::SendMessage(window_->GetNativeWindow(), WM_ACTIVATE, WA_ACTIVE, NULL);

  EXPECT_EQ(view, GetFocusManager()->GetFocusedView());
  ASSERT_EQ(2, static_cast<int>(listener.focus_changes().size()));
  EXPECT_TRUE(listener.focus_changes()[0] == ViewPair(button, null_view));
  EXPECT_TRUE(listener.focus_changes()[1] == ViewPair(null_view, view));
  */
}

// Test that the focus manager is created successfully for the first view
// window parented to a native dialog.
TEST_F(FocusManagerTest, CreationForNativeRoot) {
  // Create a window class.
  WNDCLASSEX class_ex;
  memset(&class_ex, 0, sizeof(class_ex));
  class_ex.cbSize = sizeof(WNDCLASSEX);
  class_ex.lpfnWndProc = &DefWindowProc;
  class_ex.lpszClassName = L"TestWindow";
  ATOM atom = RegisterClassEx(&class_ex);
  ASSERT_TRUE(atom);

  // Create a native dialog window.
  HWND hwnd = CreateWindowEx(0, class_ex.lpszClassName, NULL,
                             WS_OVERLAPPEDWINDOW, 0, 0, 200, 200,
                             NULL, NULL, NULL, NULL);
  ASSERT_TRUE(hwnd);

  // Create a view window parented to native dialog.
  scoped_ptr<Widget> widget1(new Widget);
  Widget::InitParams params(Widget::InitParams::TYPE_CONTROL);
  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
  params.parent = hwnd;
  params.bounds = gfx::Rect(0, 0, 100, 100);
  params.top_level = true;  // This is top level in views hierarchy.
  widget1->Init(params);

  // Get the focus manager directly from the first window.  Should exist
  // because the first window is the root widget.
  views::FocusManager* focus_manager1 = widget1->GetFocusManager();
  EXPECT_TRUE(focus_manager1);

  // Create another view window parented to the first view window.
  scoped_ptr<Widget> widget2(new Widget);
  params.parent = widget1->GetNativeView();
  params.top_level = false;  // This is child widget.
  widget2->Init(params);

  // Access the shared focus manager directly from the second window.
  views::FocusManager* focus_manager2 = widget2->GetFocusManager();
  EXPECT_EQ(focus_manager2, focus_manager1);

  // Access the shared focus manager indirectly from the first window handle.
  gfx::NativeWindow native_window = widget1->GetNativeWindow();
  views::Widget* widget =
      views::Widget::GetWidgetForNativeWindow(native_window);
  EXPECT_EQ(widget->GetFocusManager(), focus_manager1);

  // Access the shared focus manager indirectly from the second window handle.
  native_window = widget2->GetNativeWindow();
  widget = views::Widget::GetWidgetForNativeWindow(native_window);
  EXPECT_EQ(widget->GetFocusManager(), focus_manager1);

  // Access the shared focus manager indirectly from the first view handle.
  gfx::NativeView native_view = widget1->GetNativeView();
  widget = views::Widget::GetTopLevelWidgetForNativeView(native_view);
  EXPECT_EQ(widget->GetFocusManager(), focus_manager1);

  // Access the shared focus manager indirectly from the second view handle.
  native_view = widget2->GetNativeView();
  widget = views::Widget::GetTopLevelWidgetForNativeView(native_view);
  EXPECT_EQ(widget->GetFocusManager(), focus_manager1);

  DestroyWindow(hwnd);
}

// Tests that the keyup messages are eaten for accelerators.
// Windows-only, Windows is the only platform that handles accelerators in
// AcceleratorHandler. NativeWidgetAura::OnKeyEvent handles them in other
// configurations.
TEST_F(FocusManagerTest, IgnoreKeyupForAccelerators) {
  FocusManager* focus_manager = GetFocusManager();
  MessageTrackingView* mtv = new MessageTrackingView();
  mtv->AddAccelerator(ui::Accelerator(ui::VKEY_0, ui::EF_NONE));
  mtv->AddAccelerator(ui::Accelerator(ui::VKEY_1, ui::EF_NONE));
  GetContentsView()->AddChildView(mtv);
  focus_manager->SetFocusedView(mtv);

  // First send a non-accelerator key sequence.
  PostKeyDown(ui::VKEY_9);
  PostKeyUp(ui::VKEY_9);
  AcceleratorHandler accelerator_handler;
  scoped_ptr<base::RunLoop> run_loop(new base::RunLoop(&accelerator_handler));
  run_loop->RunUntilIdle();
  // Make sure we get a key-up and key-down.
  ASSERT_EQ(1U, mtv->keys_pressed().size());
  EXPECT_EQ(ui::VKEY_9, mtv->keys_pressed()[0]);
  ASSERT_EQ(1U, mtv->keys_released().size());
  EXPECT_EQ(ui::VKEY_9, mtv->keys_released()[0]);
  EXPECT_FALSE(mtv->accelerator_pressed());
  mtv->Reset();

  // Same thing with repeat and more than one key at once.
  PostKeyDown(ui::VKEY_9);
  PostKeyDown(ui::VKEY_9);
  PostKeyDown(ui::VKEY_8);
  PostKeyDown(ui::VKEY_9);
  PostKeyDown(ui::VKEY_7);
  PostKeyUp(ui::VKEY_9);
  PostKeyUp(ui::VKEY_7);
  PostKeyUp(ui::VKEY_8);
  run_loop.reset(new base::RunLoop(&accelerator_handler));
  run_loop->RunUntilIdle();
  // Make sure we get a key-up and key-down.
  ASSERT_EQ(5U, mtv->keys_pressed().size());
  EXPECT_EQ(ui::VKEY_9, mtv->keys_pressed()[0]);
  EXPECT_EQ(ui::VKEY_9, mtv->keys_pressed()[1]);
  EXPECT_EQ(ui::VKEY_8, mtv->keys_pressed()[2]);
  EXPECT_EQ(ui::VKEY_9, mtv->keys_pressed()[3]);
  EXPECT_EQ(ui::VKEY_7, mtv->keys_pressed()[4]);
  ASSERT_EQ(3U, mtv->keys_released().size());
  EXPECT_EQ(ui::VKEY_9, mtv->keys_released()[0]);
  EXPECT_EQ(ui::VKEY_7, mtv->keys_released()[1]);
  EXPECT_EQ(ui::VKEY_8, mtv->keys_released()[2]);
  EXPECT_FALSE(mtv->accelerator_pressed());
  mtv->Reset();

  // Now send an accelerator key sequence.
  PostKeyDown(ui::VKEY_0);
  PostKeyUp(ui::VKEY_0);
  run_loop.reset(new base::RunLoop(&accelerator_handler));
  run_loop->RunUntilIdle();
  EXPECT_TRUE(mtv->keys_pressed().empty());
  EXPECT_TRUE(mtv->keys_released().empty());
  EXPECT_TRUE(mtv->accelerator_pressed());
  mtv->Reset();

  // Same thing with repeat and more than one key at once.
  PostKeyDown(ui::VKEY_0);
  PostKeyDown(ui::VKEY_1);
  PostKeyDown(ui::VKEY_1);
  PostKeyDown(ui::VKEY_0);
  PostKeyDown(ui::VKEY_0);
  PostKeyUp(ui::VKEY_1);
  PostKeyUp(ui::VKEY_0);
  run_loop.reset(new base::RunLoop(&accelerator_handler));
  run_loop->RunUntilIdle();
  EXPECT_TRUE(mtv->keys_pressed().empty());
  EXPECT_TRUE(mtv->keys_released().empty());
  EXPECT_TRUE(mtv->accelerator_pressed());
  mtv->Reset();
}

}  // namespace views