diff options
Diffstat (limited to 'chrome/browser/chromeos/accessibility')
5 files changed, 399 insertions, 196 deletions
diff --git a/chrome/browser/chromeos/accessibility/accessibility_util.cc b/chrome/browser/chromeos/accessibility/accessibility_util.cc index faa58f9..86778d6 100644 --- a/chrome/browser/chromeos/accessibility/accessibility_util.cc +++ b/chrome/browser/chromeos/accessibility/accessibility_util.cc @@ -50,10 +50,6 @@ using content::RenderViewHost; namespace chromeos { namespace accessibility { -const char kScreenMagnifierOff[] = ""; -const char kScreenMagnifierFull[] = "full"; -const char kScreenMagnifierPartial[] = "partial"; - // Helper class that directly loads an extension's content scripts into // all of the frames corresponding to a given RenderViewHost. class ContentScriptLoader { @@ -123,10 +119,14 @@ void UpdateChromeOSAccessibilityHistograms() { IsHighContrastEnabled()); UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosVirtualKeyboard", IsVirtualKeyboardEnabled()); - if (MagnificationManager::Get()) + if (MagnificationManager::Get()) { + uint32 type = MagnificationManager::Get()->IsMagnifierEnabled() ? + MagnificationManager::Get()->GetMagnifierType() : 0; + // '0' means magnifier is disabled. UMA_HISTOGRAM_ENUMERATION("Accessibility.CrosScreenMagnifier", - MagnificationManager::Get()->GetMagnifierType(), - 3); + type, + ash::kMaxMagnifierType + 1); + } } void Initialize() { @@ -290,27 +290,6 @@ bool IsVirtualKeyboardEnabled() { return virtual_keyboard_enabled; } -ash::MagnifierType MagnifierTypeFromName(const char type_name[]) { - if (0 == strcmp(type_name, kScreenMagnifierFull)) - return ash::MAGNIFIER_FULL; - else if (0 == strcmp(type_name, kScreenMagnifierPartial)) - return ash::MAGNIFIER_PARTIAL; - else - return ash::MAGNIFIER_OFF; -} - -const char* ScreenMagnifierNameFromType(ash::MagnifierType type) { - switch (type) { - case ash::MAGNIFIER_OFF: - return kScreenMagnifierOff; - case ash::MAGNIFIER_FULL: - return kScreenMagnifierFull; - case ash::MAGNIFIER_PARTIAL: - return kScreenMagnifierPartial; - } - return kScreenMagnifierOff; -} - void MaybeSpeak(const std::string& utterance) { if (IsSpokenFeedbackEnabled()) Speak(utterance); diff --git a/chrome/browser/chromeos/accessibility/accessibility_util.h b/chrome/browser/chromeos/accessibility/accessibility_util.h index e672b5d..e70d60d 100644 --- a/chrome/browser/chromeos/accessibility/accessibility_util.h +++ b/chrome/browser/chromeos/accessibility/accessibility_util.h @@ -24,9 +24,19 @@ struct AccessibilityStatusEventDetails { AccessibilityStatusEventDetails( bool enabled, ash::AccessibilityNotificationVisibility notify) : enabled(enabled), + magnifier_type(ash::kDefaultMagnifierType), + notify(notify) {} + + AccessibilityStatusEventDetails( + bool enabled, + ash::MagnifierType magnifier_type, + ash::AccessibilityNotificationVisibility notify) + : enabled(enabled), + magnifier_type(magnifier_type), notify(notify) {} bool enabled; + ash::MagnifierType magnifier_type; ash::AccessibilityNotificationVisibility notify; }; @@ -64,12 +74,6 @@ bool IsHighContrastEnabled(); // Returns true if the Virtual Keyboard is enabled, or false if not. bool IsVirtualKeyboardEnabled(); -// Translates from a string to MagnifierType. -ash::MagnifierType MagnifierTypeFromName(const char type_name[]); - -// Translates from a MagnifierType to type string. -const char* ScreenMagnifierNameFromType(ash::MagnifierType type); - // Speaks the given text if the accessibility pref is already set. void MaybeSpeak(const std::string& utterance); diff --git a/chrome/browser/chromeos/accessibility/magnification_manager.cc b/chrome/browser/chromeos/accessibility/magnification_manager.cc index 25d4879..38d4f9e 100644 --- a/chrome/browser/chromeos/accessibility/magnification_manager.cc +++ b/chrome/browser/chromeos/accessibility/magnification_manager.cc @@ -34,7 +34,8 @@ class MagnificationManagerImpl : public MagnificationManager, public: MagnificationManagerImpl() : first_time_update_(true), profile_(NULL), - type_(ash::MAGNIFIER_OFF) { + type_(ash::kDefaultMagnifierType), + enabled_(false) { registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED, content::NotificationService::AllSources()); @@ -54,64 +55,114 @@ class MagnificationManagerImpl : public MagnificationManager, } // MagnificationManager implimentation: - ash::MagnifierType GetMagnifierType() OVERRIDE { + bool IsMagnifierEnabled() const OVERRIDE { + return enabled_; + } + + ash::MagnifierType GetMagnifierType() const OVERRIDE { return type_; } - void SetMagnifier(ash::MagnifierType type) OVERRIDE { - if (type == type_ && type == ash::MAGNIFIER_OFF) + void SetMagnifierEnabled(bool enabled) OVERRIDE { + // 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; - type_ = type; + enabled_ = enabled; if (profile_) { PrefService* prefs = profile_->GetPrefs(); - if (prefs) { - bool enabled = (type != ash::MAGNIFIER_OFF); - if (enabled != prefs->GetBoolean(prefs::kScreenMagnifierEnabled)) { - prefs->SetBoolean(prefs::kScreenMagnifierEnabled, enabled); - prefs->CommitPendingWrite(); - } + DCHECK(prefs); + if (enabled != prefs->GetBoolean(prefs::kScreenMagnifierEnabled)) { + prefs->SetBoolean(prefs::kScreenMagnifierEnabled, enabled); + prefs->CommitPendingWrite(); } } - accessibility::AccessibilityStatusEventDetails details( - type != ash::MAGNIFIER_OFF, ash::A11Y_NOTIFICATION_NONE); - content::NotificationService::current()->Notify( - chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFIER, - content::NotificationService::AllSources(), - content::Details<accessibility::AccessibilityStatusEventDetails>( - &details)); - - ash::Shell::GetInstance()->magnification_controller()->SetEnabled( - type == ash::MAGNIFIER_FULL); - ash::Shell::GetInstance()->partial_magnification_controller()->SetEnabled( - type == ash::MAGNIFIER_PARTIAL); + NotifyMagnifierChanged(); + + if (type_ == ash::MAGNIFIER_FULL) { + ash::Shell::GetInstance()->magnification_controller()->SetEnabled( + enabled_); + } else { + ash::Shell::GetInstance()->partial_magnification_controller()->SetEnabled( + enabled_); + } + } + + void SetMagnifierType(ash::MagnifierType type) OVERRIDE { + if (type_ == type) + return; + + DCHECK(type == ash::MAGNIFIER_FULL || type == ash::MAGNIFIER_PARTIAL); + type_ = type; + + if (profile_) { + PrefService* prefs = profile_->GetPrefs(); + DCHECK(prefs); + prefs->SetInteger(prefs::kScreenMagnifierType, type); + prefs->CommitPendingWrite(); + } + + NotifyMagnifierChanged(); + + if (enabled_) { + ash::Shell::GetInstance()->magnification_controller()->SetEnabled( + type_ == ash::MAGNIFIER_FULL); + ash::Shell::GetInstance()->partial_magnification_controller()->SetEnabled( + type_ == ash::MAGNIFIER_PARTIAL); + } } void SaveScreenMagnifierScale(double scale) OVERRIDE { Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord(); + DCHECK(profile->GetPrefs()); profile->GetPrefs()->SetDouble(prefs::kScreenMagnifierScale, scale); } - double GetSavedScreenMagnifierScale() OVERRIDE { + double GetSavedScreenMagnifierScale() const OVERRIDE { Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord(); + DCHECK(profile->GetPrefs()); if (profile->GetPrefs()->HasPrefPath(prefs::kScreenMagnifierScale)) return profile->GetPrefs()->GetDouble(prefs::kScreenMagnifierScale); return std::numeric_limits<double>::min(); } private: + void NotifyMagnifierChanged() { + accessibility::AccessibilityStatusEventDetails details( + enabled_, type_, ash::A11Y_NOTIFICATION_NONE); + content::NotificationService::current()->Notify( + chrome::NOTIFICATION_CROS_ACCESSIBILITY_TOGGLE_SCREEN_MAGNIFIER, + content::NotificationService::AllSources(), + content::Details<accessibility::AccessibilityStatusEventDetails>( + &details)); + } + + bool IsMagnifierEnabledFromPref() { + if (!profile_) + return false; + + DCHECK(profile_->GetPrefs()); + return profile_->GetPrefs()->GetBoolean(prefs::kScreenMagnifierEnabled); + } + ash::MagnifierType GetMagnifierTypeFromPref() { if (!profile_) - return ash::MAGNIFIER_OFF; + return ash::kDefaultMagnifierType; + + DCHECK(profile_->GetPrefs()); + ash::MagnifierType type = static_cast<ash::MagnifierType>( + profile_->GetPrefs()->GetInteger(prefs::kScreenMagnifierType)); - PrefService* prefs = profile_->GetPrefs(); - if (!prefs) - return ash::MAGNIFIER_OFF; + if (type == ash::MAGNIFIER_FULL || type == ash::MAGNIFIER_PARTIAL) + return type; - return prefs->GetBoolean(prefs::kScreenMagnifierEnabled) ? - ash::MAGNIFIER_FULL : ash::MAGNIFIER_OFF; + return ash::kDefaultMagnifierType; } void SetProfile(Profile* profile) { @@ -124,17 +175,27 @@ class MagnificationManagerImpl : public MagnificationManager, pref_change_registrar_->Init(profile->GetPrefs()); pref_change_registrar_->Add( prefs::kScreenMagnifierEnabled, - base::Bind(&MagnificationManagerImpl::UpdateMagnifierStatus, + base::Bind(&MagnificationManagerImpl::UpdateMagnifierStatusFromPref, + base::Unretained(this))); + pref_change_registrar_->Add( + prefs::kScreenMagnifierType, + base::Bind(&MagnificationManagerImpl::UpdateMagnifierStatusFromPref, base::Unretained(this))); } profile_ = profile; - UpdateMagnifierStatus(); + UpdateMagnifierStatusFromPref(); } - void UpdateMagnifierStatus() { - ash::MagnifierType type = GetMagnifierTypeFromPref(); - SetMagnifier(type); + void UpdateMagnifierStatusFromPref() { + bool enabled = IsMagnifierEnabledFromPref(); + if (!enabled) { + SetMagnifierEnabled(enabled); + SetMagnifierType(GetMagnifierTypeFromPref()); + } else { + SetMagnifierType(GetMagnifierTypeFromPref()); + SetMagnifierEnabled(enabled); + } } // content::NotificationObserver implimentation: @@ -168,6 +229,7 @@ class MagnificationManagerImpl : public MagnificationManager, bool first_time_update_; Profile* profile_; ash::MagnifierType type_; + bool enabled_; content::NotificationRegistrar registrar_; scoped_ptr<PrefChangeRegistrar> pref_change_registrar_; diff --git a/chrome/browser/chromeos/accessibility/magnification_manager.h b/chrome/browser/chromeos/accessibility/magnification_manager.h index 680b7fc..f323e0a 100644 --- a/chrome/browser/chromeos/accessibility/magnification_manager.h +++ b/chrome/browser/chromeos/accessibility/magnification_manager.h @@ -24,20 +24,30 @@ class MagnificationManager { // Returns the existing instance. If there is no instance, creates one. // because only one instance should exist at the same time. static void Initialize(); + // Deletes the existing instance of MagnificationManager. static void Shutdown(); + // Returns the existing instance. If there is no instance, returns NULL. static MagnificationManager* Get(); + // Returns if the screen magnifier is enabled. + virtual bool IsMagnifierEnabled() const = 0; + // Returns the current type of the screen magnifier. - virtual ash::MagnifierType GetMagnifierType() = 0; + virtual ash::MagnifierType GetMagnifierType() const = 0; + + // Enables the screen magnifier. + virtual void SetMagnifierEnabled(bool enabled) = 0; + // Changes the type of the screen magnifier. - virtual void SetMagnifier(ash::MagnifierType type) = 0; + virtual void SetMagnifierType(ash::MagnifierType type) = 0; // Saves the magnifier scale to the pref. virtual void SaveScreenMagnifierScale(double scale) = 0; + // Loads the magnifier scale from the pref. - virtual double GetSavedScreenMagnifierScale() = 0; + virtual double GetSavedScreenMagnifierScale() const = 0; protected: virtual ~MagnificationManager() {} diff --git a/chrome/browser/chromeos/accessibility/magnification_manager_browsertest.cc b/chrome/browser/chromeos/accessibility/magnification_manager_browsertest.cc index 6a1a89a..c99202a 100644 --- a/chrome/browser/chromeos/accessibility/magnification_manager_browsertest.cc +++ b/chrome/browser/chromeos/accessibility/magnification_manager_browsertest.cc @@ -24,11 +24,67 @@ namespace chromeos { +namespace { + +void SetMagnifierEnabled(bool enabled) { + MagnificationManager::Get()->SetMagnifierEnabled(enabled); +} + +void SetMagnifierType(ash::MagnifierType type) { + MagnificationManager::Get()->SetMagnifierType(type); +} + +void SetFullScreenMagnifierScale(double scale) { + ash::Shell::GetInstance()-> + magnification_controller()->SetScale(scale, false); +} + +double GetFullScreenMagnifierScale() { + return ash::Shell::GetInstance()->magnification_controller()->GetScale(); +} + +void SetSavedFullScreenMagnifierScale(double scale) { + MagnificationManager::Get()->SaveScreenMagnifierScale(scale); +} + +double GetSavedFullScreenMagnifierScale() { + return MagnificationManager::Get()->GetSavedScreenMagnifierScale(); +} + +ash::MagnifierType GetMagnifierType() { + return MagnificationManager::Get()->GetMagnifierType(); +} + +bool IsMagnifierEnabled() { + return MagnificationManager::Get()->IsMagnifierEnabled(); +} + +Profile* profile() { + Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord(); + DCHECK(profile); + return profile; +} + +PrefServiceBase* prefs() { + return PrefServiceBase::FromBrowserContext(profile()); +} + +void EnableScreenManagnifierToPref(bool enabled) { + prefs()->SetBoolean(prefs::kScreenMagnifierEnabled, enabled); +} + +void SetScreenManagnifierTypeToPref(ash::MagnifierType type) { + prefs()->SetInteger(prefs::kScreenMagnifierType, type); +} + +} // anonymouse namespace + class MagnificationManagerTest : public CrosInProcessBrowserTest, public content::NotificationObserver { protected: MagnificationManagerTest() : observed_(false), - observed_type_(ash::MAGNIFIER_OFF) {} + observed_enabled_(false), + observed_type_(ash::kDefaultMagnifierType) {} virtual ~MagnificationManagerTest() {} virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { @@ -37,16 +93,6 @@ class MagnificationManagerTest : public CrosInProcessBrowserTest, TestingProfile::kTestUserProfileDir); } - Profile* profile() { - Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord(); - DCHECK(profile); - return profile; - } - - PrefServiceBase* prefs() { - return PrefServiceBase::FromBrowserContext(profile()); - } - virtual void SetUpOnMainThread() OVERRIDE { registrar_.Add( this, @@ -54,37 +100,6 @@ class MagnificationManagerTest : public CrosInProcessBrowserTest, content::NotificationService::AllSources()); } - void SetScreenManagnifierType(ash::MagnifierType type) { - MagnificationManager::Get()->SetMagnifier(type); - } - - void SetScreenManagnifierTypeToPref(ash::MagnifierType type) { - prefs()->SetBoolean(prefs::kScreenMagnifierEnabled, - (type != ash::MAGNIFIER_OFF) ? true : false); - } - - void SetFullScreenMagnifierScale(double scale) { - ash::Shell::GetInstance()-> - magnification_controller()->SetScale(scale, false); - } - - double GetFullScreenMagnifierScale() { - return ash::Shell::GetInstance()->magnification_controller()->GetScale(); - } - - void SetSavedFullScreenMagnifierScale(double scale) { - MagnificationManager::Get()->SaveScreenMagnifierScale(scale); - } - - double GetSavedFullScreenMagnifierScale() { - return MagnificationManager::Get()->GetSavedScreenMagnifierScale(); - } - - void CheckCurrentMagnifierType( - ash::MagnifierType type) { - EXPECT_EQ(MagnificationManager::Get()->GetMagnifierType(), type); - } - // content::NotificationObserver implementation. virtual void Observe(int type, const content::NotificationSource& source, @@ -96,14 +111,15 @@ class MagnificationManagerTest : public CrosInProcessBrowserTest, details).ptr(); observed_ = true; - observed_type_ = accessibility_status->enabled ? ash::MAGNIFIER_FULL : - ash::MAGNIFIER_OFF; + observed_enabled_ = accessibility_status->enabled; + observed_type_ = accessibility_status->magnifier_type; break; } } } bool observed_; + bool observed_enabled_; ash::MagnifierType observed_type_; content::NotificationRegistrar registrar_; DISALLOW_COPY_AND_ASSIGN(MagnificationManagerTest); @@ -111,121 +127,200 @@ class MagnificationManagerTest : public CrosInProcessBrowserTest, IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, LoginOffToOff) { // Confirms that magnifier is disabled on the login screen. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); // Logs in. UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); // Confirms that magnifier is still disabled just after login. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); UserManager::Get()->SessionStarted(); // Confirms that magnifier is still disabled just after login. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); // Enables magnifier. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); // Confirms that magnifier is enabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); } IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, LoginFullToOff) { // Confirms that magnifier is disabled on the login screen. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); // Enables magnifier on login scren. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); // Logs in (but the session is not started yet). UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); // Confirms that magnifier is keeping enabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); UserManager::Get()->SessionStarted(); // Confirms that magnifier is disabled just after login. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); } IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, LoginOffToFull) { // Changes to full screen magnifier again and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); // Logs in (but the session is not started yet). UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); // Confirms that magnifier is keeping disabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); // Enable magnifier on the pref. + EnableScreenManagnifierToPref(true); SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); SetSavedFullScreenMagnifierScale(2.5); UserManager::Get()->SessionStarted(); // Confirms that the prefs are successfully loaded. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); EXPECT_EQ(2.5, GetFullScreenMagnifierScale()); } +IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, LoginOffToPartial) { + // Changes to full screen magnifier again and confirms that. + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); + + // Logs in (but the session is not started yet). + UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); + + // Confirms that magnifier is keeping disabled. + EXPECT_FALSE(IsMagnifierEnabled()); + // Enable magnifier on the pref. + EnableScreenManagnifierToPref(true); + SetScreenManagnifierTypeToPref(ash::MAGNIFIER_PARTIAL); + + UserManager::Get()->SessionStarted(); + + // Confirms that the prefs are successfully loaded. + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); + + // Full screen magnifier scale is 1.0x since it's 'partial' magnifier. + EXPECT_EQ(1.0, GetFullScreenMagnifierScale()); +} + IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, LoginFullToFull) { // Changes to full screen magnifier again and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); // Logs in (but the session is not started yet). UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); // Confirms that magnifier is keeping enabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); // Enable magnifier on the pref. + EnableScreenManagnifierToPref(true); SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); SetSavedFullScreenMagnifierScale(2.5); UserManager::Get()->SessionStarted(); // Confirms that the prefs are successfully loaded. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); EXPECT_EQ(2.5, GetFullScreenMagnifierScale()); } -IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ChangeMagnifierType) { - // Changes to full screen magnifier and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); - - // Changes to partial screen magnifier and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_PARTIAL); - CheckCurrentMagnifierType(ash::MAGNIFIER_PARTIAL); - - // Disable magnifier and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); - +IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, LoginFullToPartial) { // Changes to full screen magnifier again and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); - // Logs in + // Logs in (but the session is not started yet). UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); - UserManager::Get()->SessionStarted(); - // Changes to full screen magnifier and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + // Confirms that magnifier is keeping enabled. + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + // Enable magnifier on the pref. + EnableScreenManagnifierToPref(true); + SetScreenManagnifierTypeToPref(ash::MAGNIFIER_PARTIAL); - // Changes to partial screen magnifier and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_PARTIAL); - CheckCurrentMagnifierType(ash::MAGNIFIER_PARTIAL); + UserManager::Get()->SessionStarted(); - // Disable magnifier and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + // Confirms that the prefs are successfully loaded. + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); - // Changes to full screen magnifier again and confirms that. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + // Full screen magnifier scale is 1.0x since it's 'partial' magnifier. + EXPECT_EQ(1.0, GetFullScreenMagnifierScale()); +} + +IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ChangeMagnifierType) { + // Enables/disables full screen magnifier. + SetMagnifierEnabled(false); + SetMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + // Enables/disables partial screen magnifier. + SetMagnifierType(ash::MAGNIFIER_PARTIAL); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); + + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); + + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); + + // Changes the magnifier type when the magnifier is enabled. + SetMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + SetMagnifierType(ash::MAGNIFIER_PARTIAL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); + + SetMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + // Changes the magnifier type when the magnifier is disabled. + SetMagnifierEnabled(false); + SetMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + SetMagnifierType(ash::MAGNIFIER_PARTIAL); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); + + SetMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_FALSE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); } IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, TypePref) { @@ -234,48 +329,75 @@ IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, TypePref) { UserManager::Get()->SessionStarted(); // Confirms that magnifier is disabled just after login. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); // Sets the pref as true to enable magnifier. SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); + EnableScreenManagnifierToPref(true); // Confirms that magnifier is enabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); + + SetScreenManagnifierTypeToPref(ash::MAGNIFIER_PARTIAL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); // Sets the pref as false to disabled magnifier. - SetScreenManagnifierTypeToPref(ash::MAGNIFIER_OFF); + EnableScreenManagnifierToPref(false); // Confirms that magnifier is disabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(IsMagnifierEnabled()); // Sets the pref as true to enable magnifier again. - SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); + EnableScreenManagnifierToPref(true); // Confirms that magnifier is enabled. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); } -IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ResumeSavedTypePref) { +IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ResumeSavedTypeFullPref) { // Loads the profile of the user. UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); // Sets the pref as true to enable magnifier before login. + EnableScreenManagnifierToPref(true); SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); // Logs in. UserManager::Get()->SessionStarted(); // Confirms that magnifier is enabled just after login. - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); +} + +IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ResumeSavedTypePartialPref) { + // Loads the profile of the user. + UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); + + // Sets the pref as true to enable magnifier before login. + EnableScreenManagnifierToPref(true); + SetScreenManagnifierTypeToPref(ash::MAGNIFIER_PARTIAL); + + // Logs in. + UserManager::Get()->SessionStarted(); + + // Confirms that magnifier is enabled just after login. + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, GetMagnifierType()); } IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ScalePref) { - SetScreenManagnifierType(ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); // Sets 2.5x to the pref. SetSavedFullScreenMagnifierScale(2.5); // Enables full screen magnifier. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); // Confirms that 2.5x is restored. EXPECT_EQ(2.5, GetFullScreenMagnifierScale()); @@ -286,30 +408,33 @@ IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, ScalePref) { } IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, InvalidScalePref) { - // TEST 1: too small scale - SetScreenManagnifierType(ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + // TEST 1: Sets too small scale + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); // Sets too small value to the pref. SetSavedFullScreenMagnifierScale(0.5); // Enables full screen magnifier. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); // Confirms that the actual scale is set to the minimum scale. EXPECT_EQ(1.0, GetFullScreenMagnifierScale()); - // TEST 2: too large scale - SetScreenManagnifierType(ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + // TEST 2: Sets too large scale + SetMagnifierEnabled(false); + EXPECT_FALSE(IsMagnifierEnabled()); // Sets too large value to the pref. SetSavedFullScreenMagnifierScale(50.0); // Enables full screen magnifier. - SetScreenManagnifierType(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(IsMagnifierEnabled()); + EXPECT_EQ(ash::MAGNIFIER_FULL, GetMagnifierType()); // Confirms that the actual scale is set to the maximum scale. EXPECT_EQ(4.0, GetFullScreenMagnifierScale()); @@ -321,30 +446,53 @@ IN_PROC_BROWSER_TEST_F(MagnificationManagerTest, UserManager::Get()->UserLoggedIn("owner@invalid.domain", true); UserManager::Get()->SessionStarted(); - // Before the test, sets to full magnifier. - SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + // Enable magnifier (without type) + EnableScreenManagnifierToPref(true); + EXPECT_TRUE(observed_); // Disables magnifier and confirms observer is invoked. observed_ = false; - SetScreenManagnifierTypeToPref(ash::MAGNIFIER_OFF); + SetMagnifierEnabled(false); EXPECT_TRUE(observed_); - EXPECT_EQ(observed_type_, ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + + // Disables magnifier again and confirms observer is not invoked. + observed_ = false; + SetMagnifierEnabled(false); + EXPECT_FALSE(observed_); // Enables full screen magnifier and confirms observer is invoked. observed_ = false; - SetScreenManagnifierTypeToPref(ash::MAGNIFIER_FULL); + SetMagnifierType(ash::MAGNIFIER_FULL); + SetMagnifierEnabled(true); + EXPECT_TRUE(observed_); + + // Enables full screen magnifier again and confirms observer is invoked. + observed_ = false; + SetMagnifierEnabled(true); + EXPECT_TRUE(observed_); + EXPECT_TRUE(observed_enabled_); + EXPECT_EQ(ash::MAGNIFIER_FULL, observed_type_); + + // Switches to partial screen magnifier and confirms observer is invoked. + observed_ = false; + SetMagnifierType(ash::MAGNIFIER_PARTIAL); + EXPECT_TRUE(observed_); + EXPECT_TRUE(observed_enabled_); + EXPECT_EQ(ash::MAGNIFIER_PARTIAL, observed_type_); + + // Switches to partial screen magnifier and confirms observer is invoked. + observed_ = false; + SetMagnifierType(ash::MAGNIFIER_FULL); EXPECT_TRUE(observed_); - EXPECT_EQ(observed_type_, ash::MAGNIFIER_FULL); - CheckCurrentMagnifierType(ash::MAGNIFIER_FULL); + EXPECT_TRUE(observed_enabled_); + EXPECT_EQ(ash::MAGNIFIER_FULL, observed_type_); // Disables magnifier again and confirms observer is invoked. observed_ = false; - SetScreenManagnifierTypeToPref(ash::MAGNIFIER_OFF); + SetMagnifierEnabled(false); EXPECT_TRUE(observed_); - EXPECT_EQ(observed_type_, ash::MAGNIFIER_OFF); - CheckCurrentMagnifierType(ash::MAGNIFIER_OFF); + EXPECT_FALSE(observed_enabled_); + EXPECT_FALSE(IsMagnifierEnabled()); } } // namespace chromeos |