Use standardized and extendable accelerometer update type.

chrome/browser/chromeos/display/display_preferences_unittest.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/display/display_preferences.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/display/display_controller.h"
@@ skipping 20 matching lines @@
 
 using ash::ResolutionNotificationController;
 
 namespace chromeos {
 namespace {
 const char kPrimaryIdKey[] = "primary-id";
 const char kMirroredKey[] = "mirrored";
 const char kPositionKey[] = "position";
 const char kOffsetKey[] = "offset";
 
+// The mean acceleration due to gravity on Earth in m/s^2.
+const float kMeanGravity = 9.80665f;
+
 class DisplayPreferencesTest : public ash::test::AshTestBase {
  protected:
   DisplayPreferencesTest()
       : mock_user_manager_(new MockUserManager),
         user_manager_enabler_(mock_user_manager_) {
   }
 
   virtual ~DisplayPreferencesTest() {}
 
   virtual void SetUp() OVERRIDE {
@@ skipping 605 matching lines @@
   ash::DisplayManager* display_manager = shell->display_manager();
   LoggedInAsUser();
   // Populate the properties.
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_180);
   // Reset property to avoid rotation lock
   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                       gfx::Display::ROTATE_0);
 
   // Open up 270 degrees to trigger maximize mode
-  controller->OnAccelerometerUpdated(gfx::Vector3dF(0.0f, 0.0f, -1.0f),
-                                     gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  ui::AccelerometerUpdate update;
+  update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
+             0.0f, 0.0f, kMeanGravity);
+  update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
+             0.0f, -kMeanGravity, 0.0f);
+  controller->OnAccelerometerUpdated(update);
   EXPECT_TRUE(controller->IsMaximizeModeWindowManagerEnabled());
 
   // Trigger 90 degree rotation
-  controller->OnAccelerometerUpdated(gfx::Vector3dF(0.0f, 1.0f, 0.0f),
-                                     gfx::Vector3dF(0.0f, 1.0f, 0.0f));
+  update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
+             -kMeanGravity, 0.0f, 0.0f);
+  update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
+             -kMeanGravity, 0.0f, 0.0f);
+  controller->OnAccelerometerUpdated(update);
   EXPECT_EQ(gfx::Display::ROTATE_90, display_manager->
                 GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation());
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayProperties);
   const base::DictionaryValue* property = NULL;
   EXPECT_TRUE(properties->GetDictionary(
       base::Int64ToString(gfx::Display::InternalDisplayId()), &property));
   int rotation = -1;
   EXPECT_TRUE(property->GetInteger("rotation", &rotation));
@@ skipping 109 matching lines @@
 
   bool rotation_lock = maximize_mode_controller->rotation_locked();
   gfx::Display::Rotation before_maximize_mode_rotation = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
 
   // Settings should not be applied until maximize mode activates
   EXPECT_FALSE(rotation_lock);
   EXPECT_EQ(gfx::Display::ROTATE_0, before_maximize_mode_rotation);
 
   // Open up 270 degrees to trigger maximize mode
-  maximize_mode_controller->
-      OnAccelerometerUpdated(gfx::Vector3dF(0.0f, 0.0f, -1.0f),
-                             gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  ui::AccelerometerUpdate update;
+  update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
+             0.0f, 0.0f, kMeanGravity);
+  update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
+             0.0f, -kMeanGravity, 0.0f);
+  maximize_mode_controller->OnAccelerometerUpdated(update);
   EXPECT_TRUE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
   bool maximize_mode_rotation_lock =
       maximize_mode_controller->rotation_locked();
   gfx::Display::Rotation maximize_mode_rotation = display_manager->
       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
   EXPECT_TRUE(maximize_mode_rotation_lock);
   EXPECT_EQ(gfx::Display::ROTATE_90, maximize_mode_rotation);
 }
 
 // Tests that loaded rotation state is ignored if the device starts in normal
 // mode, and that they are not applied upon first entering maximize mode.
 TEST_F(DisplayPreferencesTest, LoadRotationIgnoredInNormalMode) {
   gfx::Display::SetInternalDisplayId(
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
   StoreDisplayRotationPrefs(false /* rotation_lock*/);
   ASSERT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   StoreDisplayRotationPrefsForTest(true, gfx::Display::ROTATE_90);
   LoadDisplayPreferences(false);
 
   ash::MaximizeModeController* maximize_mode_controller =
       ash::Shell::GetInstance()->maximize_mode_controller();
   // Lid open to 90 degrees
-  maximize_mode_controller->
-      OnAccelerometerUpdated(gfx::Vector3dF(0.0f, 0.0f, 1.0f),
-                             gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  ui::AccelerometerUpdate update;
+  update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
+             -kMeanGravity, 0.0f, 0.0f);
+  update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
+             -kMeanGravity, 0.0f, 0.0f);
+  maximize_mode_controller->OnAccelerometerUpdated(update);
   EXPECT_FALSE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
   EXPECT_FALSE(maximize_mode_controller->rotation_locked());
 
   // Open up 270 degrees to trigger maximize mode
-  maximize_mode_controller->
-      OnAccelerometerUpdated(gfx::Vector3dF(0.0f, 0.0f, -1.0f),
-                             gfx::Vector3dF(-1.0f, 0.0f, 0.0f));
+  update.Set(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD,
+             0.0f, 0.0f, kMeanGravity);
+  update.Set(ui::ACCELEROMETER_SOURCE_SCREEN,
+             0.0f, -kMeanGravity, 0.0f);
+  maximize_mode_controller->OnAccelerometerUpdated(update);
   EXPECT_TRUE(maximize_mode_controller->IsMaximizeModeWindowManagerEnabled());
   EXPECT_FALSE(maximize_mode_controller->rotation_locked());
 }
 
 // Tests that rotation lock being set causes the rotation state to be saved.
 TEST_F(DisplayPreferencesTest, RotationLockTriggersStore) {
   gfx::Display::SetInternalDisplayId(
     gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().id());
   ASSERT_FALSE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   ash::MaximizeModeController* maximize_mode_controller =
       ash::Shell::GetInstance()->maximize_mode_controller();
   maximize_mode_controller->SetRotationLocked(true);
 
   EXPECT_TRUE(local_state()->HasPrefPath(prefs::kDisplayRotationLock));
 
   const base::DictionaryValue* properties =
       local_state()->GetDictionary(prefs::kDisplayRotationLock);
   bool rotation_lock;
   EXPECT_TRUE(properties->GetBoolean("lock", &rotation_lock));
 }
 
 }  // namespace chromeos