Make chrome/browser/chromeos/accessibility compile on Athena with use_ash=0

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 28 matching lines @@
                                  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_(ash::kDefaultMagnifierType),
+        type_(ui::kDefaultMagnifierType),
         enabled_(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());
   }
 
   virtual ~MagnificationManagerImpl() {
     CHECK(this == g_magnification_manager);
   }
 
   // MagnificationManager implimentation:
   virtual bool IsMagnifierEnabled() const override {
     return enabled_;
   }
 
-  virtual ash::MagnifierType GetMagnifierType() const override {
+  virtual ui::MagnifierType GetMagnifierType() const override {
     return type_;
   }
 
   virtual void SetMagnifierEnabled(bool enabled) override {
     if (!profile_)
       return;
 
     PrefService* prefs = profile_->GetPrefs();
     prefs->SetBoolean(prefs::kAccessibilityScreenMagnifierEnabled, enabled);
     prefs->CommitPendingWrite();
   }
 
-  virtual void SetMagnifierType(ash::MagnifierType type) override {
+  virtual void SetMagnifierType(ui::MagnifierType type) override {
     if (!profile_)
       return;
 
     PrefService* prefs = profile_->GetPrefs();
     prefs->SetInteger(prefs::kAccessibilityScreenMagnifierType, type);
     prefs->CommitPendingWrite();
   }
 
   virtual void SaveScreenMagnifierScale(double scale) override {
     if (!profile_)
@@ skipping 50 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_ == ash::MAGNIFIER_FULL) {
+    if (type_ == ui::MAGNIFIER_FULL) {
       ash::Shell::GetInstance()->magnification_controller()->SetEnabled(
           enabled_);
     } else {
       ash::Shell::GetInstance()->partial_magnification_controller()->SetEnabled(
           enabled_);
     }
   }
 
-  virtual void SetMagnifierTypeInternal(ash::MagnifierType type) {
+  virtual void SetMagnifierTypeInternal(ui::MagnifierType type) {
     if (type_ == type)
       return;
 
-    type_ = ash::MAGNIFIER_FULL;  // (leave out for full magnifier)
+    type_ = ui::MAGNIFIER_FULL;  // (leave out for full magnifier)
   }
 
   void UpdateMagnifierFromPrefs() {
     if (!profile_)
       return;
 
     const bool enabled = profile_->GetPrefs()->GetBoolean(
         prefs::kAccessibilityScreenMagnifierEnabled);
     const int type_integer = profile_->GetPrefs()->GetInteger(
         prefs::kAccessibilityScreenMagnifierType);
 
-    ash::MagnifierType type = ash::kDefaultMagnifierType;
-    if (type_integer > 0 && type_integer <= ash::kMaxMagnifierType) {
-      type = static_cast<ash::MagnifierType>(type_integer);
+    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);
     } else {
       SetMagnifierTypeInternal(type);
       SetMagnifierEnabledInternal(enabled);
     }
 
     AccessibilityStatusEventDetails details(
         ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFIER,
         enabled_,
         type_,
-        ash::A11Y_NOTIFICATION_NONE);
+        ui::A11Y_NOTIFICATION_NONE);
 
 #if defined(OS_CHROMEOS)
     if (AccessibilityManager::Get()) {
       AccessibilityManager::Get()->NotifyAccessibilityStatusChanged(details);
       if (ash::Shell::GetInstance()) {
         ash::Shell::GetInstance()->SetCursorCompositingEnabled(
             AccessibilityManager::Get()->ShouldEnableCursorCompositing());
       }
     }
 #endif
@@ skipping 30 matching lines @@
     }
   }
 
   bool first_time_update_;
   Profile* profile_;
 
   AccessibilityManager::PrefHandler magnifier_enabled_pref_handler_;
   AccessibilityManager::PrefHandler magnifier_type_pref_handler_;
   AccessibilityManager::PrefHandler magnifier_scale_pref_handler_;
 
-  ash::MagnifierType type_;
+  ui::MagnifierType type_;
   bool enabled_;
 
   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