Center the focus of the text input in magnifier screen.

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"
@@ skipping 30 matching lines @@
  public:
   MagnificationManagerImpl()
       : 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),
+        keep_focus_centered_(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 58 matching lines @@
       pref_change_registrar_.reset(new PrefChangeRegistrar);
       pref_change_registrar_->Init(profile->GetPrefs());
       pref_change_registrar_->Add(
           prefs::kAccessibilityScreenMagnifierEnabled,
           base::Bind(&MagnificationManagerImpl::UpdateMagnifierFromPrefs,
                      base::Unretained(this)));
       pref_change_registrar_->Add(
           prefs::kAccessibilityScreenMagnifierType,
           base::Bind(&MagnificationManagerImpl::UpdateMagnifierFromPrefs,
                      base::Unretained(this)));
+      pref_change_registrar_->Add(
+          prefs::kAccessibilityScreenMagnifierCenterFocus,
+          base::Bind(&MagnificationManagerImpl::UpdateMagnifierFromPrefs,
+                     base::Unretained(this)));
     }
 
     magnifier_enabled_pref_handler_.HandleProfileChanged(profile_, profile);
     magnifier_type_pref_handler_.HandleProfileChanged(profile_, profile);
     magnifier_scale_pref_handler_.HandleProfileChanged(profile_, profile);
 
     profile_ = profile;
     UpdateMagnifierFromPrefs();
   }
 
@@ skipping 18 matching lines @@
     }
   }
 
   virtual void SetMagnifierTypeInternal(ui::MagnifierType type) {
     if (type_ == type)
       return;
 
     type_ = ui::MAGNIFIER_FULL;  // (leave out for full magnifier)
   }
 
+  virtual void SetMagniferKeepFocusCenteredInternal(bool keep_focus_centered) {
+    if (keep_focus_centered_ == keep_focus_centered)
+      return;
+
+    keep_focus_centered_ = keep_focus_centered;
+
+    if (type_ == ui::MAGNIFIER_FULL) {
+      ash::Shell::GetInstance()
+          ->magnification_controller()
+          ->SetKeepFocusCentered(keep_focus_centered_);
+    }
+  }
+
   void UpdateMagnifierFromPrefs() {
     if (!profile_)
       return;
 
     const bool enabled = profile_->GetPrefs()->GetBoolean(
         prefs::kAccessibilityScreenMagnifierEnabled);
     const int type_integer = profile_->GetPrefs()->GetInteger(
         prefs::kAccessibilityScreenMagnifierType);
+    const bool keep_focus_centered = profile_->GetPrefs()->GetBoolean(
+        prefs::kAccessibilityScreenMagnifierCenterFocus);
 
     ui::MagnifierType type = ui::kDefaultMagnifierType;
     if (type_integer > 0 && type_integer <= ui::kMaxMagnifierType) {
       type = static_cast<ui::MagnifierType>(type_integer);
     } else if (type_integer == 0) {
       // Type 0 is used to disable the screen magnifier through policy. As the
       // magnifier type is irrelevant in this case, it is OK to just fall back
       // to the default.
     } else {
       NOTREACHED();
     }
 
     if (!enabled) {
       SetMagnifierEnabledInternal(enabled);
       SetMagnifierTypeInternal(type);
+      SetMagniferKeepFocusCenteredInternal(keep_focus_centered);
     } else {
+      SetMagniferKeepFocusCenteredInternal(keep_focus_centered);
       SetMagnifierTypeInternal(type);
       SetMagnifierEnabledInternal(enabled);
     }
 
     AccessibilityStatusEventDetails details(
         ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFIER,
         enabled_,
         type_,
         ui::A11Y_NOTIFICATION_NONE);
 
@@ skipping 59 matching lines @@
   }
 
   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 keep_focus_centered_;
   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