Allow controls other than windows to send alert accessibility events.

chrome/browser/ui/views/accessibility/accessibility_event_router_views_unittest.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 <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/accessibility/accessibility_extension_api.h"
+#include "chrome/browser/accessibility/accessibility_extension_api_constants.h"
 #include "chrome/browser/ui/views/accessibility/accessibility_event_router_views.h"
 #include "chrome/test/base/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/base/accessibility/accessibility_types.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/widget/native_widget.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
@@ skipping 72 matching lines @@
 
  private:
   string16 name_;
   ui::AccessibilityTypes::Role role_;
   DISALLOW_COPY_AND_ASSIGN(ViewWithNameAndRole);
 };
 
 class AccessibilityEventRouterViewsTest
     : public testing::Test {
  public:
-  AccessibilityEventRouterViewsTest() : focus_event_count_(0) {
+  AccessibilityEventRouterViewsTest() : control_event_count_(0) {
   }
 
   virtual void SetUp() {
 #if defined(OS_WIN)
     ole_initializer_.reset(new ui::ScopedOleInitializer());
 #endif
     views::ViewsDelegate::views_delegate = new AccessibilityViewsDelegate();
 #if defined(USE_AURA)
     aura_test_helper_.reset(new aura::test::AuraTestHelper(&message_loop_));
     aura_test_helper_->SetUp();
@@ skipping 34 matching lines @@
 
     return widget;
   }
 
   void EnableAccessibilityAndListenToFocusNotifications() {
     // Switch on accessibility event notifications.
     ExtensionAccessibilityEventRouter* accessibility_event_router =
         ExtensionAccessibilityEventRouter::GetInstance();
     accessibility_event_router->SetAccessibilityEnabled(true);
     accessibility_event_router->SetControlEventCallbackForTesting(base::Bind(
-        &AccessibilityEventRouterViewsTest::OnFocusEvent,
+        &AccessibilityEventRouterViewsTest::OnControlEvent,
         base::Unretained(this)));
   }
 
   void ClearCallback() {
     ExtensionAccessibilityEventRouter* accessibility_event_router =
         ExtensionAccessibilityEventRouter::GetInstance();
     accessibility_event_router->ClearControlEventCallback();
   }
 
  protected:
   // Handle Focus event.
-  virtual void OnFocusEvent(ui::AccessibilityTypes::Event event,
+  virtual void OnControlEvent(ui::AccessibilityTypes::Event event,
                             const AccessibilityControlInfo* info) {
-    focus_event_count_++;
+    control_event_count_++;
+    last_control_type_ = info->type();
     last_control_name_ = info->name();
     last_control_context_ = info->context();
   }
 
   base::MessageLoopForUI message_loop_;
-  int focus_event_count_;
+  int control_event_count_;
+  std::string last_control_type_;
   std::string last_control_name_;
   std::string last_control_context_;
   TestingProfile profile_;
 #if defined(OS_WIN)
   scoped_ptr<ui::ScopedOleInitializer> ole_initializer_;
 #endif
 #if defined(USE_AURA)
   scoped_ptr<aura::test::AuraTestHelper> aura_test_helper_;
 #endif
 };
@@ skipping 28 matching lines @@
   // callback.
   button1->RequestFocus();
   base::MessageLoop::current()->RunUntilIdle();
 
   // Change the accessible name of button3.
   button3->SetAccessibleName(ASCIIToUTF16(kButton3NewASCII));
 
   // Advance focus to the next button and test that we got the
   // expected notification with the name of button 2.
   views::FocusManager* focus_manager = contents->GetWidget()->GetFocusManager();
-  focus_event_count_ = 0;
+  control_event_count_ = 0;
   focus_manager->AdvanceFocus(false);
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(1, focus_event_count_);
+  EXPECT_EQ(1, control_event_count_);
   EXPECT_EQ(kButton2ASCII, last_control_name_);
 
   // Advance to button 3. Expect the new accessible name we assigned.
   focus_manager->AdvanceFocus(false);
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(2, focus_event_count_);
+  EXPECT_EQ(2, control_event_count_);
   EXPECT_EQ(kButton3NewASCII, last_control_name_);
 
   // Advance to button 1 and check the notification.
   focus_manager->AdvanceFocus(false);
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(3, focus_event_count_);
+  EXPECT_EQ(3, control_event_count_);
   EXPECT_EQ(kButton1ASCII, last_control_name_);
 
   window->CloseNow();
 }
 
 TEST_F(AccessibilityEventRouterViewsTest, TestToolbarContext) {
   const char kToolbarNameASCII[] = "MyToolbar";
   const char kButtonNameASCII[] = "MyButton";
 
   // Create a toolbar with a button.
   views::View* contents = new ViewWithNameAndRole(
       ASCIIToUTF16(kToolbarNameASCII),
       ui::AccessibilityTypes::ROLE_TOOLBAR);
   views::LabelButton* button = new views::LabelButton(
       NULL, ASCIIToUTF16(kButtonNameASCII));
   button->SetStyle(views::Button::STYLE_NATIVE_TEXTBUTTON);
   contents->AddChildView(button);
 
   // Put the view in a window.
   views::Widget* window = CreateWindowWithContents(contents);
 
   // Set focus to the button.
-  focus_event_count_ = 0;
+  control_event_count_ = 0;
   button->RequestFocus();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Test that we got the event with the expected name and context.
-  EXPECT_EQ(kInitialFocusCount, focus_event_count_);
+  EXPECT_EQ(kInitialFocusCount, control_event_count_);
   EXPECT_EQ(kButtonNameASCII, last_control_name_);
   EXPECT_EQ(kToolbarNameASCII, last_control_context_);
 
   window->CloseNow();
 }
 
 TEST_F(AccessibilityEventRouterViewsTest, TestAlertContext) {
   const char kAlertTextASCII[] = "MyAlertText";
   const char kButtonNameASCII[] = "MyButton";
 
   // Create an alert with static text and a button, similar to an infobar.
   views::View* contents = new ViewWithNameAndRole(
       string16(),
       ui::AccessibilityTypes::ROLE_ALERT);
   views::Label* label = new views::Label(ASCIIToUTF16(kAlertTextASCII));
   contents->AddChildView(label);
   views::LabelButton* button = new views::LabelButton(
       NULL, ASCIIToUTF16(kButtonNameASCII));
   button->SetStyle(views::Button::STYLE_NATIVE_TEXTBUTTON);
   contents->AddChildView(button);
 
   // Put the view in a window.
   views::Widget* window = CreateWindowWithContents(contents);
 
   // Set focus to the button.
-  focus_event_count_ = 0;
+  control_event_count_ = 0;
   button->RequestFocus();
 
   base::MessageLoop::current()->RunUntilIdle();
 
   // Test that we got the event with the expected name and context.
-  EXPECT_EQ(kInitialFocusCount, focus_event_count_);
+  EXPECT_EQ(kInitialFocusCount, control_event_count_);
   EXPECT_EQ(kButtonNameASCII, last_control_name_);
   EXPECT_EQ(kAlertTextASCII, last_control_context_);
 
   window->CloseNow();
 }
 
 TEST_F(AccessibilityEventRouterViewsTest, StateChangeAfterNotification) {
   const char kContentsNameASCII[] = "Contents";
   const char kOldNameASCII[] = "OldName";
   const char kNewNameASCII[] = "NewName";
 
   // Create a toolbar with a button.
   views::View* contents = new ViewWithNameAndRole(
       ASCIIToUTF16(kContentsNameASCII),
       ui::AccessibilityTypes::ROLE_CLIENT);
   ViewWithNameAndRole* child = new ViewWithNameAndRole(
       ASCIIToUTF16(kOldNameASCII),
       ui::AccessibilityTypes::ROLE_PUSHBUTTON);
   child->set_focusable(true);
   contents->AddChildView(child);
 
   // Put the view in a window.
   views::Widget* window = CreateWindowWithContents(contents);
 
   // Set focus to the child view.
-  focus_event_count_ = 0;
+  control_event_count_ = 0;
   child->RequestFocus();
 
   // Change the child's name after the focus notification.
   child->set_name(ASCIIToUTF16(kNewNameASCII));
 
   // We shouldn't get the notification right away.
-  EXPECT_EQ(0, focus_event_count_);
+  EXPECT_EQ(0, control_event_count_);
 
   // Process anything in the event loop. Now we should get the notification,
   // and it should give us the new control name, not the old one.
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(kInitialFocusCount, focus_event_count_);
+  EXPECT_EQ(kInitialFocusCount, control_event_count_);
   EXPECT_EQ(kNewNameASCII, last_control_name_);
 
   window->CloseNow();
 }
 
 TEST_F(AccessibilityEventRouterViewsTest, NotificationOnDeletedObject) {
   const char kContentsNameASCII[] = "Contents";
   const char kNameASCII[] = "OldName";
 
   // Create a toolbar with a button.
   views::View* contents = new ViewWithNameAndRole(
       ASCIIToUTF16(kContentsNameASCII),
       ui::AccessibilityTypes::ROLE_CLIENT);
   ViewWithNameAndRole* child = new ViewWithNameAndRole(
       ASCIIToUTF16(kNameASCII),
       ui::AccessibilityTypes::ROLE_PUSHBUTTON);
   child->set_focusable(true);
   contents->AddChildView(child);
 
   // Put the view in a window.
   views::Widget* window = CreateWindowWithContents(contents);
 
   // Set focus to the child view.
-  focus_event_count_ = 0;
+  control_event_count_ = 0;
   child->RequestFocus();
 
   // Delete the child!
   delete child;
 
   // We shouldn't get the notification right away.
-  EXPECT_EQ(0, focus_event_count_);
+  EXPECT_EQ(0, control_event_count_);
 
   // Process anything in the event loop. We shouldn't get a notification
   // because the view is no longer valid, and this shouldn't crash.
   base::MessageLoop::current()->RunUntilIdle();
-  EXPECT_EQ(0, focus_event_count_);
+  EXPECT_EQ(0, control_event_count_);
 
   window->CloseNow();
 }
+
+TEST_F(AccessibilityEventRouterViewsTest, AlertsFromWindowAndControl) {
+  const char kButtonASCII[] = "Button";
+  const char* kTypeAlert = extension_accessibility_api_constants::kTypeAlert;
+  const char* kTypeWindow = extension_accessibility_api_constants::kTypeWindow;
+
+  // Create a contents view with a button.
+  views::View* contents = new views::View();
+  views::LabelButton* button = new views::LabelButton(
+      NULL, ASCIIToUTF16(kButtonASCII));
+  button->SetStyle(views::Button::STYLE_NATIVE_TEXTBUTTON);
+  contents->AddChildView(button);
+
+  // Put the view in a window.
+  views::Widget* window = CreateWindowWithContents(contents);
+  window->Show();
+  window->Activate();

[sky, 2013/11/16 00:28:46]

If you're relying on activation then this needs to be in interactive ui tests.

[dmazzoni, 2013/11/16 00:35:14]

I think this is okay. This test is really a unit test and doesn't depend on the
window being active. I added the call to Activate above because it was done in
other views unittests.

If it seems to work without the call to Activate, should we get rid of it? In
general should we get rid of Activate in other views unittests?

+
+  // Send an alert event from the button and let the event loop run.
+  control_event_count_ = 0;
+  button->NotifyAccessibilityEvent(ui::AccessibilityTypes::EVENT_ALERT, true);
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(kTypeAlert, last_control_type_);
+  EXPECT_EQ(1, control_event_count_);
+  EXPECT_EQ(kButtonASCII, last_control_name_);
+
+  // Send an alert event from the window and let the event loop run.
+  control_event_count_ = 0;
+  window->GetRootView()->NotifyAccessibilityEvent(
+      ui::AccessibilityTypes::EVENT_ALERT, true);
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(1, control_event_count_);
+  EXPECT_EQ(kTypeWindow, last_control_type_);
+
+  window->CloseNow();
+}