Focus following for the non-editable controls on web page in magnifier mode.

chrome/browser/chromeos/accessibility/magnification_manager.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 "chrome/browser/chromeos/accessibility/magnification_manager.h"
 
 #include <limits>
 
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
+#include "content/public/browser/focused_node_details.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 namespace chromeos {
 
 namespace {
 static MagnificationManager* g_magnification_manager = NULL;
 }
 
 class MagnificationManagerImpl : public MagnificationManager,
                                  public content::NotificationObserver,
                                  public ash::SessionStateObserver {
  public:
   MagnificationManagerImpl()
       : first_time_update_(true),
         profile_(NULL),
         magnifier_enabled_pref_handler_(
             prefs::kAccessibilityScreenMagnifierEnabled),
         magnifier_type_pref_handler_(prefs::kAccessibilityScreenMagnifierType),
         magnifier_scale_pref_handler_(
             prefs::kAccessibilityScreenMagnifierScale),
         type_(ui::kDefaultMagnifierType),
-        enabled_(false) {
+        enabled_(false),
+        observing_focus_change_in_page_(false) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_SESSION_STARTED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::NotificationService::AllSources());
   }
@@ skipping 87 matching lines @@
     // magnifier is already disabled, we are sure that we don't need to reflect
     // the new settings right now because the magnifier keeps disabled.
     if (!enabled && !enabled_)
       return;
 
     enabled_ = enabled;
 
     if (type_ == ui::MAGNIFIER_FULL) {
       ash::Shell::GetInstance()->magnification_controller()->SetEnabled(
           enabled_);
+      MonitorFocusInPageChange();
     } else {
       ash::Shell::GetInstance()->partial_magnification_controller()->SetEnabled(
           enabled_);
     }
   }
 
   virtual void SetMagnifierTypeInternal(ui::MagnifierType type) {
     if (type_ == type)
       return;
 
@@ skipping 38 matching lines @@
     if (AccessibilityManager::Get()) {
       AccessibilityManager::Get()->NotifyAccessibilityStatusChanged(details);
       if (ash::Shell::GetInstance()) {
         ash::Shell::GetInstance()->SetCursorCompositingEnabled(
             AccessibilityManager::Get()->ShouldEnableCursorCompositing());
       }
     }
 #endif
   }
 
+  void MonitorFocusInPageChange() {
+    if (enabled_ && !observing_focus_change_in_page_) {
+      registrar_.Add(this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
+                     content::NotificationService::AllSources());
+      observing_focus_change_in_page_ = true;
+    } else if (!enabled_ && observing_focus_change_in_page_) {
+      registrar_.Remove(this, content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE,
+                        content::NotificationService::AllSources());
+      observing_focus_change_in_page_ = false;
+    }
+  }
+
   // content::NotificationObserver implementation:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) override {
     switch (type) {
       case chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE: {
         // Update |profile_| when entering the login screen.
         Profile* profile = ProfileManager::GetActiveUserProfile();
         if (ProfileHelper::IsSigninProfile(profile))
           SetProfile(profile);
         break;
       }
       case chrome::NOTIFICATION_SESSION_STARTED:
         // Update |profile_| when entering a session.
         SetProfile(ProfileManager::GetActiveUserProfile());
 
         // Add a session state observer to be able to monitor session changes.
         if (!session_state_observer_.get() && ash::Shell::HasInstance())
           session_state_observer_.reset(
               new ash::ScopedSessionStateObserver(this));
         break;
       case chrome::NOTIFICATION_PROFILE_DESTROYED: {
         // Update |profile_| when exiting a session or shutting down.
         Profile* profile = content::Source<Profile>(source).ptr();
         if (profile_ == profile)
           SetProfile(NULL);
         break;
       }
+      case content::NOTIFICATION_FOCUS_CHANGED_IN_PAGE: {
+        content::FocusedNodeDetails* node_details =
+            content::Details<content::FocusedNodeDetails>(details).ptr();
+        ash::Shell::GetInstance()
+            ->magnification_controller()
+            ->HandleFocusedNodeChanged(node_details->is_editable_node,
+                                       node_details->node_bounds_in_screen);
+        break;
+      }
     }
   }
 
   bool first_time_update_;
   Profile* profile_;
 
   AccessibilityManager::PrefHandler magnifier_enabled_pref_handler_;
   AccessibilityManager::PrefHandler magnifier_type_pref_handler_;
   AccessibilityManager::PrefHandler magnifier_scale_pref_handler_;
 
   ui::MagnifierType type_;
   bool enabled_;
+  bool observing_focus_change_in_page_;
 
   content::NotificationRegistrar registrar_;
   scoped_ptr<PrefChangeRegistrar> pref_change_registrar_;
   scoped_ptr<ash::ScopedSessionStateObserver> session_state_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(MagnificationManagerImpl);
 };
 
 // static
 void MagnificationManager::Initialize() {
   CHECK(g_magnification_manager == NULL);
   g_magnification_manager = new MagnificationManagerImpl();
 }
 
 // static
 void MagnificationManager::Shutdown() {
   CHECK(g_magnification_manager);
   delete g_magnification_manager;
   g_magnification_manager = NULL;
 }
 
 // static
 MagnificationManager* MagnificationManager::Get() {
   return g_magnification_manager;
 }
 
 }  // namespace chromeos