mash: Move accessibility_types.h from ui namespace to ash namespace

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 <memory>
 
+#include "ash/common/accessibility_types.h"
 #include "ash/common/session/session_state_observer.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
@@ skipping 22 matching lines @@
                                  public content::NotificationObserver,
                                  public ash::SessionStateObserver {
  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),
+        type_(ash::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());
   }
 
   ~MagnificationManagerImpl() override {
     CHECK(this == g_magnification_manager);
   }
 
   // MagnificationManager implimentation:
   bool IsMagnifierEnabled() const override { return enabled_; }
 
-  ui::MagnifierType GetMagnifierType() const override { return type_; }
+  ash::MagnifierType GetMagnifierType() const override { return type_; }
 
   void SetMagnifierEnabled(bool enabled) override {
     if (!profile_)
       return;
 
     PrefService* prefs = profile_->GetPrefs();
     prefs->SetBoolean(prefs::kAccessibilityScreenMagnifierEnabled, enabled);
     prefs->CommitPendingWrite();
   }
 
-  void SetMagnifierType(ui::MagnifierType type) override {
+  void SetMagnifierType(ash::MagnifierType type) override {
     if (!profile_)
       return;
 
     PrefService* prefs = profile_->GetPrefs();
     prefs->SetInteger(prefs::kAccessibilityScreenMagnifierType, type);
     prefs->CommitPendingWrite();
   }
 
   void SaveScreenMagnifierScale(double scale) override {
     if (!profile_)
@@ skipping 52 matching lines @@
     // This method may be invoked even when the other magnifier settings (e.g.
     // type or scale) are changed, so we need to call magnification controller
     // even if |enabled| is unchanged. Only if |enabled| is false and the
     // 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) {
+    if (type_ == ash::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) {
+  virtual void SetMagnifierTypeInternal(ash::MagnifierType type) {
     if (type_ == type)
       return;
 
-    type_ = ui::MAGNIFIER_FULL;  // (leave out for full magnifier)
+    type_ = ash::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) {
+    if (type_ == ash::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);
+    ash::MagnifierType type = ash::kDefaultMagnifierType;
+    if (type_integer > 0 && type_integer <= ash::kMaxMagnifierType) {
+      type = static_cast<ash::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);
+        ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFIER, enabled_, type_,
+        ash::A11Y_NOTIFICATION_NONE);
 
     if (AccessibilityManager::Get()) {
       AccessibilityManager::Get()->NotifyAccessibilityStatusChanged(details);
       if (ash::Shell::GetInstance()) {
         ash::Shell::GetInstance()->SetCursorCompositingEnabled(
             AccessibilityManager::Get()->ShouldEnableCursorCompositing());
       }
     }
   }
 
@@ skipping 48 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_;
+  ash::MagnifierType type_;
   bool enabled_;
   bool keep_focus_centered_;
   bool observing_focus_change_in_page_;
 
   content::NotificationRegistrar registrar_;
   std::unique_ptr<PrefChangeRegistrar> pref_change_registrar_;
   std::unique_ptr<ash::ScopedSessionStateObserver> session_state_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(MagnificationManagerImpl);
 };
@@ skipping 10 matching lines @@
   delete g_magnification_manager;
   g_magnification_manager = NULL;
 }
 
 // static
 MagnificationManager* MagnificationManager::Get() {
   return g_magnification_manager;
 }
 
 }  // namespace chromeos