Implementing accelerators for Linux toolkit_views

views/focus/focus_manager_unittest.cc

 // Copyright (c) 2006-2008 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.
 
 // Disabled right now as this won't work on BuildBots right now as this test
 // require the box it runs on to be unlocked (and no screen-savers).
 // The test actually simulates mouse and key events, so if the screen is locked,
 // the events don't go to the Chrome window.
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "app/resource_bundle.h"
 #include "base/gfx/rect.h"
+#include "base/keyboard_codes.h"
 #include "base/string_util.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "views/background.h"
 #include "views/border.h"
 #include "views/controls/button/checkbox.h"
 #include "views/controls/button/native_button.h"
 #include "views/controls/button/radio_button.h"
 #include "views/controls/combobox/combobox.h"
 #include "views/controls/combobox/native_combobox_wrapper.h"
 #include "views/controls/label.h"
 #include "views/controls/link.h"
+#if defined(OS_WIN)
 #include "views/controls/native_control.h"
 #include "views/controls/scroll_view.h"
 #include "views/controls/tabbed_pane/native_tabbed_pane_wrapper.h"
 #include "views/controls/tabbed_pane/tabbed_pane.h"
 #include "views/controls/textfield/textfield.h"
-#include "views/widget/accelerator_handler.h"
+#endif
+#include "views/focus/accelerator_handler.h"
 #include "views/widget/root_view.h"
+#include "views/window/window.h"
+#include "views/window/window_delegate.h"
+
+#if defined(OS_WIN)
 #include "views/widget/widget_win.h"
-#include "views/window/window_delegate.h"
 #include "views/window/window_win.h"
+#else
+#include "views/window/window_gtk.h"
+#endif
 
 namespace views {
 
+#if defined(OS_WIN)
 static const int kWindowWidth = 600;
 static const int kWindowHeight = 500;
 
 static int count = 1;
 
 static const int kTopCheckBoxID = count++;  // 1
 static const int kLeftContainerID = count++;
 static const int kAppleLabelID = count++;
 static const int kAppleTextfieldID = count++;
 static const int kOrangeLabelID = count++;  // 5
@@ skipping 39 matching lines @@
 static const int kStyleTextEditID = count++;
 
 static const int kSearchContainerID = count++;
 static const int kSearchTextfieldID = count++;
 static const int kSearchButtonID = count++;
 static const int kHelpLinkID = count++;  // 45
 
 static const int kThumbnailContainerID = count++;
 static const int kThumbnailStarID = count++;
 static const int kThumbnailSuperStarID = count++;
+#endif
 
-class FocusManagerTest;
+class FocusManagerTest : public testing::Test, public WindowDelegate {
+ public:
+  FocusManagerTest()
+      : window_(NULL),
+        content_view_(NULL),
+        focus_change_listener_(NULL) {
+#if defined(OS_WIN)
+    OleInitialize(NULL);
+#endif
+  }
 
+  ~FocusManagerTest() {
+#if defined(OS_WIN)
+    OleUninitialize();
+#endif
+  }
+
+  virtual void SetUp() {
+    window_ = Window::CreateChromeWindow(NULL, bounds(), this);
+    InitContentView();
+    window_->Show();
+  }
+
+  virtual void TearDown() {
+    if (focus_change_listener_)
+      GetFocusManager()->RemoveFocusChangeListener(focus_change_listener_);
+    //    window_->CloseNow();
+    window_->Close();
+
+    // Flush the message loop to make Purify happy.
+    message_loop()->RunAllPending();
+  }
+
+  FocusManager* GetFocusManager() {
+#if defined(OS_WIN)
+    return static_cast<WindowWin*>(window_)->GetFocusManager();
+#elif defined(OS_LINUX)
+    return static_cast<WindowGtk*>(window_)->GetFocusManager();
+#elif
+    NOTIMPLEMENTED();
+#endif
+  }
+
+  // WindowDelegate Implementation.
+  virtual View* GetContentsView() {
+    if (!content_view_)
+      content_view_ = new View();
+    return content_view_;
+  }
+
+  virtual void InitContentView() {
+  }
+
+ protected:
+  virtual gfx::Rect bounds() {
+    return gfx::Rect(0, 0, 500, 500);
+  }
+
+#if defined(OS_WIN)
+  // Mocks activating/deactivating the window.
+  void SimulateActivateWindow() {
+    ::SendMessage(window_->GetNativeWindow(), WM_ACTIVATE, WA_ACTIVE, NULL);
+  }
+  void SimulateDeactivateWindow() {
+    ::SendMessage(window_->GetNativeWindow(), WM_ACTIVATE, WA_INACTIVE, NULL);
+  }
+#endif
+
+  MessageLoopForUI* message_loop() { return &message_loop_; }
+
+  Window* window_;
+  View* content_view_;
+
+  void AddFocusChangeListener(FocusChangeListener* listener) {
+    ASSERT_FALSE(focus_change_listener_);
+    focus_change_listener_ = listener;
+    GetFocusManager()->AddFocusChangeListener(listener);
+  }
+
+ private:
+  FocusChangeListener* focus_change_listener_;
+  MessageLoopForUI message_loop_;
+
+  DISALLOW_COPY_AND_ASSIGN(FocusManagerTest);
+};
+
+#if defined(OS_WIN)
 // BorderView is a NativeControl that creates a tab control as its child and
 // takes a View to add as the child of the tab control. The tab control is used
 // to give a nice background for the view. At some point we'll have a real
 // wrapper for TabControl, and this can be nuked in favor of it.
 // Taken from keyword_editor_view.cc.
 // It is interesting in our test as it is a native control containing another
 // RootView.
 class BorderView : public NativeControl {
  public:
   explicit BorderView(View* child) : child_(child) {
@@ skipping 67 matching lines @@
 
 class DummyComboboxModel : public Combobox::Model {
  public:
   virtual int GetItemCount(Combobox* source) { return 10; }
 
   virtual std::wstring GetItemAt(Combobox* source, int index) {
     return L"Item " + IntToWString(index);
   }
 };
 
-class FocusManagerTest : public testing::Test, public WindowDelegate {
- public:
-  FocusManagerTest()
-      : window_(NULL),
-        focus_change_listener_(NULL),
-        content_view_(NULL) {
-    OleInitialize(NULL);
-  }
-
-  ~FocusManagerTest() {
-    OleUninitialize();
-  }
-
-  virtual void SetUp() {
-    window_ = static_cast<WindowWin*>(
-        Window::CreateChromeWindow(NULL, bounds(), this));
-    InitContentView();
-    window_->Show();
-  }
-
-  virtual void TearDown() {
-    if (focus_change_listener_)
-      GetFocusManager()->RemoveFocusChangeListener(focus_change_listener_);
-    window_->CloseNow();
-
-    // Flush the message loop to make Purify happy.
-    message_loop()->RunAllPending();
-  }
-
-  FocusManager* GetFocusManager() {
-    return FocusManager::GetFocusManagerForNativeView(
-        window_->GetNativeWindow());
-  }
-
-  // WindowDelegate Implementation.
-  virtual View* GetContentsView() {
-    if (!content_view_)
-      content_view_ = new View();
-    return content_view_;
-  }
-
-  virtual void InitContentView() {
-  }
-
- protected:
-  virtual gfx::Rect bounds() {
-    return gfx::Rect(0, 0, 500, 500);
-  }
-
-  // Mocks activating/deactivating the window.
-  void SimulateActivateWindow() {
-    ::SendMessage(window_->GetNativeWindow(), WM_ACTIVATE, WA_ACTIVE, NULL);
-  }
-  void SimulateDeactivateWindow() {
-    ::SendMessage(window_->GetNativeWindow(), WM_ACTIVATE, WA_INACTIVE, NULL);
-  }
-
-  MessageLoopForUI* message_loop() { return &message_loop_; }
-
-  WindowWin* window_;
-  View* content_view_;
-
-  void AddFocusChangeListener(FocusChangeListener* listener) {
-    ASSERT_FALSE(focus_change_listener_);
-    focus_change_listener_ = listener;
-    GetFocusManager()->AddFocusChangeListener(listener);
-  }
-
- private:
-  FocusChangeListener* focus_change_listener_;
-  MessageLoopForUI message_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(FocusManagerTest);
-};
-
 class FocusTraversalTest : public FocusManagerTest {
  public:
   ~FocusTraversalTest();
 
   virtual void InitContentView();
 
  protected:
   FocusTraversalTest();
 
   virtual gfx::Rect bounds() {
@@ skipping 697 matching lines @@
     for (int j = arraysize(kTraversalIDs) - 1; j >= 0; --j) {
       GetFocusManager()->AdvanceFocus(true);
       focused_view = GetFocusManager()->GetFocusedView();
       EXPECT_TRUE(focused_view != NULL);
       if (focused_view)
         EXPECT_EQ(kTraversalIDs[j], focused_view->GetID());
     }
   }
 }
 
+#endif  // WIN_OS
+
 // Counts accelerator calls.
 class TestAcceleratorTarget : public AcceleratorTarget {
  public:
   explicit TestAcceleratorTarget(bool process_accelerator)
       : accelerator_count_(0), process_accelerator_(process_accelerator) {}
 
   virtual bool AcceleratorPressed(const Accelerator& accelerator) {
     ++accelerator_count_;
     return process_accelerator_;
   }
 
   int accelerator_count() const { return accelerator_count_; }
 
  private:
   int accelerator_count_;  // number of times that the accelerator is activated
   bool process_accelerator_;  // return value of AcceleratorPressed
 
   DISALLOW_COPY_AND_ASSIGN(TestAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(VK_RETURN, false, false, false);
-  Accelerator escape_accelerator(VK_ESCAPE, false, false, false);
+  Accelerator return_accelerator(base::VKEY_RETURN, false, false, false);
+  Accelerator escape_accelerator(base::VKEY_ESCAPE, false, false, false);
 
   TestAcceleratorTarget return_target(true);
   TestAcceleratorTarget escape_target(true);
   EXPECT_EQ(return_target.accelerator_count(), 0);
   EXPECT_EQ(escape_target.accelerator_count(), 0);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
 
@@ skipping 96 matching lines @@
  private:
   Accelerator accelerator_;
   FocusManager* focus_manager_;
   int accelerator_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SelfUnregisteringAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(VK_RETURN, false, false, false);
+  Accelerator return_accelerator(base::VKEY_RETURN, false, false, false);
   SelfUnregisteringAcceleratorTarget target(return_accelerator, focus_manager);
   EXPECT_EQ(target.accelerator_count(), 0);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Register the target.
   focus_manager->RegisterAccelerator(return_accelerator, &target);
   EXPECT_EQ(&target,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Hitting the return key. The target will be unregistered.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(target.accelerator_count(), 1);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Hitting the return key again; nothing should happen.
   EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(target.accelerator_count(), 1);
 }
 
 }  // namespace views