cros: Remove OS_CHROMEOS ifdefs in ash/common

ash/common/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/common/wm/maximize_mode/maximize_mode_controller.h"
 
 #include <utility>
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/common/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
 #include "ash/common/wm_shell.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "ui/base/accelerators/accelerator.h"
+#include "ui/chromeos/accelerometer/accelerometer_util.h"
 #include "ui/display/display.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 
-#if defined(OS_CHROMEOS)
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "ui/chromeos/accelerometer/accelerometer_util.h"
-#endif  // OS_CHROMEOS
-
 namespace ash {
 
 namespace {
 
-#if defined(OS_CHROMEOS)
 // The hinge angle at which to enter maximize mode.
 const float kEnterMaximizeModeAngle = 200.0f;
 
 // The angle at which to exit maximize mode, this is specifically less than the
 // angle to enter maximize mode to prevent rapid toggling when near the angle.
 const float kExitMaximizeModeAngle = 160.0f;
 
 // Defines a range for which accelerometer readings are considered accurate.
 // When the lid is near open (or near closed) the accelerometer readings may be
 // inaccurate and a lid that is fully open may appear to be near closed (and
 // vice versa).
 const float kMinStableAngle = 20.0f;
 const float kMaxStableAngle = 340.0f;
-#endif  // OS_CHROMEOS
 
 // The time duration to consider the lid to be recently opened.
 // This is used to prevent entering maximize mode if an erroneous accelerometer
 // reading makes the lid appear to be fully open when the user is opening the
 // lid from a closed position.
 const int kLidRecentlyOpenedDurationSeconds = 2;
 
-#if defined(OS_CHROMEOS)
 // When the device approaches vertical orientation (i.e. portrait orientation)
 // the accelerometers for the base and lid approach the same values (i.e.
 // gravity pointing in the direction of the hinge). When this happens abrupt
 // small acceleration perpendicular to the hinge can lead to incorrect hinge
 // angle calculations. To prevent this the accelerometer updates will be
 // smoothed over time in order to reduce this noise.
 // This is the minimum acceleration parallel to the hinge under which to begin
 // smoothing in m/s^2.
 const float kHingeVerticalSmoothingStart = 7.0f;
 // This is the maximum acceleration parallel to the hinge under which smoothing
@@ skipping 11 matching lines @@
 bool IsAngleBetweenAccelerometerReadingsStable(
     const chromeos::AccelerometerUpdate& update) {
   return std::abs(
              ui::ConvertAccelerometerReadingToVector3dF(
                  update.get(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD))
                  .Length() -
              ui::ConvertAccelerometerReadingToVector3dF(
                  update.get(chromeos::ACCELEROMETER_SOURCE_SCREEN))
                  .Length()) <= kNoisyMagnitudeDeviation;
 }
-#endif  // OS_CHROMEOS
 
 bool IsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAshEnableTouchView);
 }
 
 }  // namespace
 
 MaximizeModeController::MaximizeModeController()
     : have_seen_accelerometer_data_(false),
       touchview_usage_interval_start_time_(base::Time::Now()),
       tick_clock_(new base::DefaultTickClock()),
-#if defined(OS_CHROMEOS)
       tablet_mode_switch_is_on_(false),
-#endif
       lid_is_closed_(false) {
   WmShell::Get()->AddShellObserver(this);
   WmShell::Get()->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_INITIALLY_DISABLED);
 
   // TODO(jonross): Do not create MaximizeModeController if the flag is
   // unavailable. This will require refactoring
   // IsMaximizeModeWindowManagerEnabled to check for the existance of the
   // controller.
   const bool is_enabled = IsEnabled();
   if (is_enabled)
     WmShell::Get()->AddDisplayObserver(this);
 
-#if defined(OS_CHROMEOS)
   if (is_enabled)
     chromeos::AccelerometerReader::GetInstance()->AddObserver(this);
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(
       this);
-#endif  // OS_CHROMEOS
 }
 
 MaximizeModeController::~MaximizeModeController() {
   WmShell::Get()->RemoveShellObserver(this);
   const bool is_enabled = IsEnabled();
   if (is_enabled)
     WmShell::Get()->RemoveDisplayObserver(this);
 
-#if defined(OS_CHROMEOS)
   if (is_enabled)
     chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
       this);
-#endif  // OS_CHROMEOS
 }
 
 bool MaximizeModeController::CanEnterMaximizeMode() {
   // If we have ever seen accelerometer data, then HandleHingeRotation may
   // trigger maximize mode at some point in the future.
   // The --enable-touch-view-testing switch can also mean that we may enter
   // maximize mode.
   // TODO(mgiuca): This can result in false positives, as it returns true for
   // any device with an accelerometer. Have TouchView-enabled devices explicitly
   // set a flag, and change this implementation to simply return true iff the
@@ skipping 42 matching lines @@
 void MaximizeModeController::AddWindow(WmWindow* window) {
   if (IsMaximizeModeWindowManagerEnabled())
     maximize_mode_window_manager_->AddWindow(window);
 }
 
 void MaximizeModeController::BindRequest(
     mojom::TouchViewManagerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
-#if defined(OS_CHROMEOS)
 void MaximizeModeController::OnAccelerometerUpdated(
     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))
     return;
 
   if (!display::Display::HasInternalDisplay())
     return;
@@ skipping 109 matching lines @@
   // Toggle maximize mode on or off when corresponding thresholds are passed.
   if (IsMaximizeModeWindowManagerEnabled() && is_angle_stable &&
       lid_angle <= kExitMaximizeModeAngle) {
     LeaveMaximizeMode();
   } else if (!IsMaximizeModeWindowManagerEnabled() && !lid_is_closed_ &&
              lid_angle >= kEnterMaximizeModeAngle &&
              (is_angle_stable || !WasLidOpenedRecently())) {
     EnterMaximizeMode();
   }
 }
-#endif  // OS_CHROMEOS
 
 void MaximizeModeController::EnterMaximizeMode() {
   // Always reset first to avoid creation before destruction of a previous
   // object.
   event_blocker_ =
       WmShell::Get()->CreateScopedDisableInternalMouseAndKeyboard();
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAshEnableTouchViewTesting)) {
     // We don't let accelerometer updates interfere with the maximize mode
@@ skipping 105 matching lines @@
   return elapsed_time.InSeconds() <= kLidRecentlyOpenedDurationSeconds;
 }
 
 void MaximizeModeController::SetTickClockForTest(
     std::unique_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock_);
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ash