Suppressed screen rotation notifications triggeres by the accelerometer

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/accelerometer/accelerometer_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/maximize_mode/maximize_mode_event_blocker.h"
 #include "ui/gfx/vector3d_f.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/notification_blocker.h"
 
 namespace ash {
 
 namespace {
 
 // 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.
@@ skipping 27 matching lines @@
 // rotate to match it (i.e. 45.0f is no stickiness).
 const float kDisplayRotationStickyAngleDegrees = 60.0f;
 
 // The minimum acceleration in a direction required to trigger screen rotation.
 // This prevents rapid toggling of rotation when the device is near flat and
 // there is very little screen aligned force on it.
 const float kMinimumAccelerationScreenRotation = 0.3f;
 
 const float kRadiansToDegrees = 180.0f / 3.14159265f;
 
+// A message centre notification blocker used to suppress screen rotation
+// events caused by accelerometer events
+class ScreenRotationNotificationBlocker

[flackr, 2014/05/05 19:06:00]

nit: Just call this ScopedNotificationBlocker. It doesn't discriminate by type
of notification :-).

[bruthig, 2014/05/05 19:35:35]

Done.

+    : public message_center::NotificationBlocker {
+ public:
+  ScreenRotationNotificationBlocker()

[flackr, 2014/05/05 19:06:00]

nit: I don't think any of these methods should be inlined:
http://www.chromium.org/developers/coding-style#TOC-Inline-functions

[bruthig, 2014/05/05 19:35:35]

Done.

+      : message_center::NotificationBlocker(
+            message_center::MessageCenter::Get()) {
+    NotifyBlockingStateChanged();
+  }
+
+  virtual ~ScreenRotationNotificationBlocker() {
+  };
+
+ private:
+  // Overriden from message_center::NotificationBlocker.
+  virtual bool ShouldShowNotificationAsPopup(
+      const message_center::NotifierId& notifier_id) const OVERRIDE {
+    return false;
+  }
+
+// Overriden from message_center::NotificationBlocker.
+  virtual bool ShouldShowNotification(
+      const message_center::NotifierId& notifier_id) const OVERRIDE {
+    return false;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenRotationNotificationBlocker);
+};
+
 // Returns the angle between |base| and |other| in degrees.
 float AngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
                                  const gfx::Vector3dF& other) {
   return acos(gfx::DotProduct(base, other) /
               base.Length() / other.Length()) * kRadiansToDegrees;
 }
 
 // Returns the clockwise angle between |base| and |other| where |normal| is the
 // normal of the virtual surface to measure clockwise according to.
 float ClockwiseAngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
@@ skipping 31 matching lines @@
   float lid_magnitude = lid.Length();
   if (std::abs(base_magnitude - lid_magnitude) > kNoisyMagnitudeDeviation ||
       std::abs(base_magnitude - 1.0f) > kDeviationFromGravityThreshold ||
       std::abs(lid_magnitude - 1.0f) > kDeviationFromGravityThreshold) {
       return;
   }
 
   // Responding to the hinge rotation can change the maximize mode state which
   // affects screen rotation, so we handle hinge rotation first.
   HandleHingeRotation(base, lid);
-  HandleScreenRotation(lid);
+  {
+    // Suppress message centre notifications for screen rotations caused
+    // by accelerometer events because it should be obvious why the orientation
+    // changed.
+    ScreenRotationNotificationBlocker notification_blocker;

[flackr, 2014/05/05 19:06:00]

This method (OnAccelerometerUpdated) is called fairly frequently. I think it
might be worth just blocking before we actually call SetRotation rather than
everytime HandleScreenRotation is called just not knowing the performance cost
of this. You can separate out SetRotation into a method on
MaximizeModeController to avoid any code duplication.

[bruthig, 2014/05/05 19:35:35]

Done.

+    HandleScreenRotation(lid);
+  }
 }
 
 void MaximizeModeController::HandleHingeRotation(const gfx::Vector3dF& base,
                                                  const gfx::Vector3dF& lid) {
   static const gfx::Vector3dF hinge_vector(0.0f, 1.0f, 0.0f);
   bool maximize_mode_engaged =
       Shell::GetInstance()->IsMaximizeModeWindowManagerEnabled();
   // Ignore the component of acceleration parallel to the hinge for the purposes
   // of hinge angle calculation.
   gfx::Vector3dF base_flattened(base);
@@ skipping 106 matching lines @@
   // When exiting maximize mode return rotation to 0. When entering, rotate to
   // match screen orientation.
   if (new_rotation == gfx::Display::ROTATE_0 ||
       maximize_mode_engaged) {
     display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
                                         new_rotation);
   }
 }
 
 }  // namespace ash