Rotate screen in response to accelerator or device orientation sensors.

ui/aura/test/test_screen.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 "ui/aura/test/test_screen.h"
 
 #include "base/logging.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 
 namespace aura {
 
+namespace {
+
+bool IsRotationPortrait(gfx::Display::Rotation rotation) {
+  return rotation == gfx::Display::ROTATE_90 ||
+         rotation == gfx::Display::ROTATE_270;
+}
+
+}  // namespace
+
 // static
 TestScreen* TestScreen::Create(const gfx::Size& size) {
   const gfx::Size kDefaultSize(800, 600);
   // Use (0,0) because the desktop aura tests are executed in
   // native environment where the display's origin is (0,0).
   return new TestScreen(gfx::Rect(size.IsEmpty() ? kDefaultSize : size));
 }
 
 // static
 TestScreen* TestScreen::CreateFullscreen() {
@@ skipping 11 matching lines @@
   return host_;
 }
 
 void TestScreen::SetDeviceScaleFactor(float device_scale_factor) {
   gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
   display_.SetScaleAndBounds(device_scale_factor, bounds_in_pixel);
   host_->OnHostResized(bounds_in_pixel.size());
 }
 
 void TestScreen::SetDisplayRotation(gfx::Display::Rotation rotation) {
+  gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
+  gfx::Rect new_bounds(bounds_in_pixel);
+  if (IsRotationPortrait(rotation) != IsRotationPortrait(display_.rotation())) {
+    new_bounds.set_width(bounds_in_pixel.height());
+    new_bounds.set_height(bounds_in_pixel.width());
+  }
   display_.set_rotation(rotation);
-  // TODO(oshima|mukai): Update the display_ as well.
+  display_.SetScaleAndBounds(display_.device_scale_factor(), new_bounds);
   host_->SetRootTransform(GetRotationTransform() * GetUIScaleTransform());
 }
 
 void TestScreen::SetUIScale(float ui_scale) {
   ui_scale_ = ui_scale;
   gfx::Rect bounds_in_pixel(display_.GetSizeInPixel());
   gfx::Rect new_bounds = gfx::ToNearestRect(
       gfx::ScaleRect(bounds_in_pixel, 1.0f / ui_scale));
   display_.SetScaleAndBounds(display_.device_scale_factor(), new_bounds);
   host_->SetRootTransform(GetRotationTransform() * GetUIScaleTransform());
 }
 
 gfx::Transform TestScreen::GetRotationTransform() const {
   gfx::Transform rotate;
-  float one_pixel = 1.0f / display_.device_scale_factor();
   switch (display_.rotation()) {
     case gfx::Display::ROTATE_0:
       break;
     case gfx::Display::ROTATE_90:
-      rotate.Translate(display_.bounds().height() - one_pixel, 0);
+      rotate.Translate(display_.bounds().height(), 0);
       rotate.Rotate(90);
       break;
     case gfx::Display::ROTATE_270:
-      rotate.Translate(0, display_.bounds().width() - one_pixel);
+      rotate.Translate(0, display_.bounds().width());
       rotate.Rotate(270);
       break;
     case gfx::Display::ROTATE_180:
-      rotate.Translate(display_.bounds().width() - one_pixel,
-                       display_.bounds().height() - one_pixel);
+      rotate.Translate(display_.bounds().width(),
+                       display_.bounds().height());
       rotate.Rotate(180);
       break;
   }
 
   return rotate;
 }
 
 gfx::Transform TestScreen::GetUIScaleTransform() const {
   gfx::Transform ui_scale;
   ui_scale.Scale(1.0f / ui_scale_, 1.0f / ui_scale_);
@@ skipping 61 matching lines @@
 
 TestScreen::TestScreen(const gfx::Rect& screen_bounds)
     : host_(NULL),
       ui_scale_(1.0f) {
   static int64 synthesized_display_id = 2000;
   display_.set_id(synthesized_display_id++);
   display_.SetScaleAndBounds(1.0f, screen_bounds);
 }
 
 }  // namespace aura