Implement DeviceMotionEvent API

ash/wm/maximize_mode/maximize_mode_controller.cc

 // Copyright 2014 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 "ash/wm/maximize_mode/maximize_mode_controller.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 133 matching lines @@
   return maximize_mode_window_manager_.get() != NULL;
 }
 
 void MaximizeModeController::AddWindow(aura::Window* window) {
   if (IsMaximizeModeWindowManagerEnabled())
     maximize_mode_window_manager_->AddWindow(window);
 }
 
 #if defined(OS_CHROMEOS)
 void MaximizeModeController::OnAccelerometerUpdated(
-    const chromeos::AccelerometerUpdate& update) {
+    scoped_refptr<const chromeos::AccelerometerUpdate> update) {
   bool first_accelerometer_update = !have_seen_accelerometer_data_;
   have_seen_accelerometer_data_ = true;
 
-  if (!update.has(chromeos::ACCELEROMETER_SOURCE_SCREEN))
+  if (!update->has(chromeos::ACCELEROMETER_SOURCE_SCREEN))
     return;
 
   // Whether or not we enter maximize mode affects whether we handle screen
   // rotation, so determine whether to enter maximize mode first.
-  if (!update.has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)) {
+  if (!update->has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)) {
     if (first_accelerometer_update)
       EnterMaximizeMode();
   } else if (ui::IsAccelerometerReadingStable(
-                 update, chromeos::ACCELEROMETER_SOURCE_SCREEN) &&
+                 *update, chromeos::ACCELEROMETER_SOURCE_SCREEN) &&
              ui::IsAccelerometerReadingStable(
-                 update, chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) &&
-             IsAngleBetweenAccelerometerReadingsStable(update)) {
+                 *update, chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) &&
+             IsAngleBetweenAccelerometerReadingsStable(*update)) {
     // update.has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)
     // Ignore the reading if it appears unstable. The reading is considered
     // unstable if it deviates too much from gravity and/or the magnitude of the
     // reading from the lid differs too much from the reading from the base.
-    HandleHingeRotation(update);
+    HandleHingeRotation(update.get());
   }
 }
 
 void MaximizeModeController::LidEventReceived(bool open,
                                               const base::TimeTicks& time) {
   if (open)
     last_lid_open_time_ = time;
   lid_is_closed_ = !open;
   LeaveMaximizeMode();
 }
 
 void MaximizeModeController::SuspendImminent() {
   // The system is about to suspend, so record TouchView usage interval metrics
   // based on whether TouchView mode is currently active.
   RecordTouchViewUsageInterval(CurrentTouchViewIntervalType());
 }
 
 void MaximizeModeController::SuspendDone(
     const base::TimeDelta& sleep_duration) {
   // We do not want TouchView usage metrics to include time spent in suspend.
   touchview_usage_interval_start_time_ = base::Time::Now();
 }
 
 void MaximizeModeController::HandleHingeRotation(
-    const chromeos::AccelerometerUpdate& update) {
+    const chromeos::AccelerometerUpdate* update) {
   static const gfx::Vector3dF hinge_vector(1.0f, 0.0f, 0.0f);
   // Ignore the component of acceleration parallel to the hinge for the purposes
   // of hinge angle calculation.
   gfx::Vector3dF base_flattened(ui::ConvertAccelerometerReadingToVector3dF(
-      update.get(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)));
+      update->get(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD)));
   gfx::Vector3dF lid_flattened(ui::ConvertAccelerometerReadingToVector3dF(
-      update.get(chromeos::ACCELEROMETER_SOURCE_SCREEN)));
+      update->get(chromeos::ACCELEROMETER_SOURCE_SCREEN)));
   base_flattened.set_x(0.0f);
   lid_flattened.set_x(0.0f);
 
   // As the hinge approaches a vertical angle, the base and lid accelerometers
   // approach the same values making any angle calculations highly inaccurate.
   // Bail out early when it is too close.
   if (base_flattened.Length() < kHingeAngleDetectionThreshold ||
       lid_flattened.Length() < kHingeAngleDetectionThreshold) {
     return;
   }
@@ skipping 121 matching lines @@
   return elapsed_time <= kLidRecentlyOpenedDuration;
 }
 
 void MaximizeModeController::SetTickClockForTest(
     scoped_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock_);
   tick_clock_ = tick_clock.Pass();
 }
 
 }  // namespace ash