Unity 8

Merge lp:~dandrader/unity8/splashRotation into lp:unity8

splashRotation
Merge into trunk

Proposed by Daniel d'Andrada on 2016-06-14

Status:

Merged

Approved by:

Albert Astals Cid on 2016-06-23

Approved revision:

2496

Merged at revision:

2556

Proposed branch:

lp:~dandrader/unity8/splashRotation

Merge into:

lp:unity8

Diff against target:

527 lines (+233/-105)

5 files modified

qml/Stages/ApplicationWindow.qml (+6/-0)
qml/Stages/SpreadDelegate.qml (+71/-81)
tests/mocks/Unity/Application/MirSurfaceItem.cpp (+39/-12)
tests/mocks/Unity/Application/MirSurfaceItem.h (+2/-0)
tests/qmltests/Stages/tst_SpreadDelegate.qml (+115/-12)

To merge this branch:

bzr merge lp:~dandrader/unity8/splashRotation

High

Invalid

Link a bug report

Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot	continuous-integration		Needs Fixing on 2016-06-29
Albert Astals Cid (community)		2016-06-14	Approve on 2016-06-23
Review via email: mp+297318@code.launchpad.net

Commit Message

Fix splashscreen orientation when app rotates own contents

+ Refactor states code in SpreadDelegate, removing redundancy

+ Fix mock MirSurfaceItem::orientationAngle implementation,
mirroring what the real implementation in qtmir does.

Description of the Change

* Are there any related MPs required for this MP to build/function as expected? Please list.
No

* Did you perform an exploratory manual test run of your code change and any related functionality?
Yes

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
Not applicable

* If you changed the UI, has there been a design review?
Not applicable

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-14:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1470/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-14:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1473/rebuild

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2016-06-15:

Is there a way to reproduce the bug with any of the make tryXYZ tools we have? I've been trying but couldn't figure out how to make it happen.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-15:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1476/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2016-06-15:

On 15/06/2016 05:54, Albert Astals Cid wrote:
> Is there a way to reproduce the bug with any of the make tryXYZ tools we have? I've been trying but couldn't figure out how to make it happen.

Sure.

- make tryOrientedShell
- Select "flo" in the Device Name drop-down list
- Unlock shell
- Drag in the launcher and click on the camera-app icon

Albert Astals Cid (aacid) wrote on 2016-06-21:

> Mir::OrientationAngle *m_orientationAngle{nullptr};

Please be consistent with the existing implementation and move it to the constructor.

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2016-06-21:

On 21/06/2016 09:26, Albert Astals Cid wrote:
> Review: Needs Fixing
>
>> Mir::OrientationAngle *m_orientationAngle{nullptr};
> Please be consistent with the existing implementation and move it to the constructor.

Done

Albert Astals Cid (aacid) wrote on 2016-06-21:

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

* Did CI run pass? If not, please explain why.
Unstable unrelated tests, passed fine locally

review: Approve

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-21:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1584/rebuild

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2016-06-22:

Found a regression:
* Be in dash in vertical orientation
* Open Cut the rope from app scope
* Wait until Cut the rope is animating the rectangle in the main screen
* Change the phone to horizontal orientation
* Do a quick swipe on the right to return to dash
* Quickly after being in dash put the phone in vertical orientation
* Get http://i.imgur.com/KQGUBqI.png

I can reproduce this fairly easy 2 out of 3 times with this branch and not at all without it.

review: Needs Fixing

lp:~dandrader/unity8/splashRotation updated on 2016-06-22

2493. By Daniel d'Andrada on 2016-06-22

Fix mock MirSurfaceItem::orientationAngle implementation

Mirroring what the real implementation in qtmir does.

2494. By Daniel d'Andrada on 2016-06-22

Fix splashscreen orientation when app rotates own contents

2495. By Daniel d'Andrada on 2016-06-22

Write regression test

2496. By Daniel d'Andrada on 2016-06-22

Fix regression found during code review

Daniel d'Andrada (dandrader) wrote on 2016-06-22:

> Found a regression:
> * Be in dash in vertical orientation
> * Open Cut the rope from app scope
> * Wait until Cut the rope is animating the rectangle in the main screen
> * Change the phone to horizontal orientation
> * Do a quick swipe on the right to return to dash
> * Quickly after being in dash put the phone in vertical orientation
> * Get http://i.imgur.com/KQGUBqI.png
>
> I can reproduce this fairly easy 2 out of 3 times with this branch and not at
> all without it.

Fixed, thanks.

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-22:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1595/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-22:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1597/rebuild

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2016-06-23:

How hard would it be to add a testcase for that last regression fix you made?

review: Needs Information

Daniel d'Andrada (dandrader) wrote on 2016-06-23:

On 23/06/2016 06:36, Albert Astals Cid wrote:
> Review: Needs Information
>
> How hard would it be to add a testcase for that last regression fix you made?

I did it already. It's
http://bazaar.launchpad.net/~dandrader/unity8/splashRotation/revision/2495

Albert Astals Cid (aacid) wrote on 2016-06-23:

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes, here's hoping i didn't do an incomplete testing like before :D

* Did CI run pass? If not, please explain why.
Almost yes, the main job failed in somewhere that doesn't really matter.

review: Approve

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-06-29:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-ci/1633/rebuild

review: Needs Fixing (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Daniel d'Andrada

Mohammad Rakibul Hasan

Unity Team

 === modified file 'qml/Stages/ApplicationWindow.qml'
 --- qml/Stages/ApplicationWindow.qml	2016-06-02 12:02:35 +0000
 +++ qml/Stages/ApplicationWindow.qml	2016-06-22 20:20:30 +0000
@@ -46,6 +46,7 @@
      property alias resizeSurface: surfaceContainer.resizeSurface
      property int requestedWidth: -1
      property int requestedHeight: -1
++    property real splashRotation: 0
      readonly property int minimumWidth: surface ? surface.minimumWidth : 0
      readonly property int minimumHeight: surface ? surface.minimumHeight : 0
@@ -184,6 +185,11 @@
                  backgroundColor: d.splashColor
                  headerColor: d.splashColorHeader
                  footerColor: d.splashColorFooter
++
++                rotation: root.splashRotation
++                anchors.centerIn: parent
++                width: rotation == 0 || rotation == 180 ? root.width : root.height
++                height: rotation == 0 || rotation == 180 ? root.height : root.width
+             }
+         }
+     }
 === modified file 'qml/Stages/SpreadDelegate.qml'
 --- qml/Stages/SpreadDelegate.qml	2016-06-17 01:16:36 +0000
 +++ qml/Stages/SpreadDelegate.qml	2016-06-22 20:20:30 +0000
@@ -82,12 +82,69 @@
      QtObject {
          id: priv
++        objectName: "spreadDelegatePriv"
          property bool startingUp: true
+     }
      Component.onCompleted: { finishStartUpTimer.start(); }
      Timer { id: finishStartUpTimer; interval: 400; onTriggered: priv.startingUp = false }
++    // JS version of QPlatformScreen::angleBetween C++ implementation.
++    // So don't ask me how it works because I don't know.
++    // Calling Screen.angleBetween from within a Binding component doesn't work for some reason.
++    function angleBetween(a, b) {
++        if (a == b)
++            return 0;
++
++        var ia = Math.log(a) / Math.LN2;
++        var ib = Math.log(b) / Math.LN2;
++
++        var delta = ia - ib;
++
++        if (delta < 0)
++            delta = delta + 4;
++
++        var angles = [ 0, 90, 180, 270 ];
++        return angles[delta];
++    }
++
++    // Sets the initial orientationAngle of the window, when it first slides into view
++    // (with the splash screen likely being displayed). At that point we just try to
++    // match shell's current orientation. We need a bit of time in this state as the
++    // information we need to decide orientationAngle may take a few cycles to
++    // be set.
++    Binding {
++        target: appWindowWithShadow
++        property: "orientationAngle"
++        when: priv.startingUp
++        value: {
++            var supportedOrientations = root.supportedOrientations;
++
++            if (supportedOrientations === Qt.PrimaryOrientation) {
++                supportedOrientations = root.orientations.primary;
++            }
++
++            // If it doesn't support shell's current orientation
++            // then simply pick some arbitraty one that it does support
++            var chosenOrientation = 0;
++            if (supportedOrientations & root.shellOrientation) {
++                chosenOrientation = root.shellOrientation;
++            } else if (supportedOrientations & Qt.PortraitOrientation) {
++                chosenOrientation = root.orientations.portrait;
++            } else if (supportedOrientations & Qt.LandscapeOrientation) {
++                chosenOrientation = root.orientations.landscape;
++            } else if (supportedOrientations & Qt.InvertedPortraitOrientation) {
++                chosenOrientation = root.orientations.invertedPortrait;
++            } else if (supportedOrientations & Qt.InvertedLandscapeOrientation) {
++                chosenOrientation = root.orientations.invertedLandscape;
++            } else {
++                chosenOrientation = root.orientations.primary;
++            }
++
++            return angleBetween(root.orientations.native_, chosenOrientation);
++        }
++    }
++
      Rectangle {
          id: background
          color: "black"
@@ -129,9 +186,7 @@
+             }
              state: {
--                if (priv.startingUp) {
--                    return "startingUp";
--                } else if (root.application && root.application.rotatesWindowContents) {
++                if (root.application && root.application.rotatesWindowContents) {
                      return "counterRotate";
                  } else if (orientationChangeAnimation.running) {
                      return "animatingRotation";
@@ -149,118 +204,53 @@
+             }
              states: [
--                // Sets the initial orientationAngle of the window, when it first slides into view
--                // (with the splash screen likely being displayed). At that point we just try to
--                // match shell's current orientation. We need a bit of time in this state as the
--                // information we need to decide orientationAngle may take a few cycles to
--                // be set.
++                // A base state containing bindings common to others
++                // Ensures appWindowWithShadow fills the root area.
                  State {
--                    name: "startingUp"
++                    name: "fillRootArea"
                      PropertyChanges {
                          target: appWindowWithShadow
                          restoreEntryValues: false
--                        orientationAngle: {
--                            if (!root.application || root.application.rotatesWindowContents) {
--                                return 0;
--                            }
--
--                            var supportedOrientations = root.supportedOrientations;
--
--                            if (supportedOrientations === Qt.PrimaryOrientation) {
--                                supportedOrientations = root.orientations.primary;
--                            }
--
--                            // If it doesn't support shell's current orientation
--                            // then simply pick some arbitraty one that it does support
--                            var chosenOrientation = 0;
--                            if (supportedOrientations & root.shellOrientation) {
--                                chosenOrientation = root.shellOrientation;
--                            } else if (supportedOrientations & Qt.PortraitOrientation) {
--                                chosenOrientation = root.orientations.portrait;
--                            } else if (supportedOrientations & Qt.LandscapeOrientation) {
--                                chosenOrientation = root.orientations.landscape;
--                            } else if (supportedOrientations & Qt.InvertedPortraitOrientation) {
--                                chosenOrientation = root.orientations.invertedPortrait;
--                            } else if (supportedOrientations & Qt.InvertedLandscapeOrientation) {
--                                chosenOrientation = root.orientations.invertedLandscape;
--                            } else {
--                                chosenOrientation = root.orientations.primary;
--                            }
--
--                            return Screen.angleBetween(root.orientations.native_, chosenOrientation);
--                        }
--
--                        rotation: normalizeAngle(appWindowWithShadow.orientationAngle - root.shellOrientationAngle)
--                        width: {
--                            if (rotation == 0 || rotation == 180) {
--                                return root.width;
--                            } else {
--                                return root.height;
--                            }
--                        }
--                        height: {
--                            if (rotation == 0 || rotation == 180)
--                                return root.height;
--                            else
--                                return root.width;
--                        }
++                        width: appWindowWithShadow.rotation == 0 || appWindowWithShadow.rotation == 180 ? root.width : root.height
++                        height: appWindowWithShadow.rotation == 0 || appWindowWithShadow.rotation == 180 ? root.height : root.width
+                     }
                  },
                  // In this state we stick to our currently set orientationAngle, which may change only due
                  // to calls made to matchShellOrientation() or animateToShellOrientation()
                  State {
--                    id: keepSceneRotationState
                      name: "keepSceneRotation"
--
--                    StateChangeScript { script: {
--                        // break binding
--                        appWindowWithShadow.orientationAngle = appWindowWithShadow.orientationAngle;
--                    } }
++                    extend: "fillRootArea"
                      PropertyChanges {
                          target: appWindowWithShadow
                          restoreEntryValues: false
                          rotation: normalizeAngle(appWindowWithShadow.orientationAngle - root.shellOrientationAngle)
--                        width: {
--                            if (rotation == 0 || rotation == 180) {
--                                return root.width;
--                            } else {
--                                return root.height;
--                            }
--                        }
--                        height: {
--                            if (rotation == 0 || rotation == 180)
--                                return root.height;
--                            else
--                                return root.width;
--                        }
+                     }
                  },
                  // In this state we counteract any shell rotation so that the window, in scene coordinates,
                  // remains unrotated.
++                // But the splash screen should still obey the set orientationAngle set by shell
                  State {
                      name: "counterRotate"
--                    StateChangeScript { script: {
--                        // break binding
--                        appWindowWithShadow.orientationAngle = appWindowWithShadow.orientationAngle;
--                    } }
++                    extend: "fillRootArea"
                      PropertyChanges {
                          target: appWindowWithShadow
--                        width: root.shellOrientationAngle == 0 || root.shellOrientationAngle == 180 ? root.width : root.height
--                        height: root.shellOrientationAngle == 0 || root.shellOrientationAngle == 180 ? root.height : root.width
                          rotation: normalizeAngle(-root.shellOrientationAngle)
+                     }
                      PropertyChanges {
                          target: appWindow
                          surfaceOrientationAngle: appWindowWithShadow.orientationAngle
++                        splashRotation: appWindowWithShadow.orientationAngle
+                     }
                  },
++                // Dummy state.
++                // The animation may indiscriminately break any bindings assigned to appWindowWithShadow rotation,
++                // width or height.
                  State {
                      name: "animatingRotation"
+                 }
+             ]
--            x: (parent.width - width) / 2
--            y: (parent.height - height) / 2
++            anchors.centerIn: parent
              BorderImage {
                  anchors {
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.cpp'
 --- tests/mocks/Unity/Application/MirSurfaceItem.cpp	2016-05-26 13:15:35 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.cpp	2016-06-22 20:20:30 +0000
@@ -43,6 +43,7 @@
      , m_qmlContentComponent(nullptr)
      , m_qmlItem(nullptr)
      , m_consumesInput(false)
++    , m_orientationAngle(nullptr)
      , m_surfaceWidth(0)
      , m_surfaceHeight(0)
      , m_touchPressCount(0)
@@ -68,6 +69,7 @@
+ {
      DEBUG_MSG((void*)(this) << name());
      setSurface(nullptr);
++    delete m_orientationAngle;
+ }
  void MirSurfaceItem::printComponentErrors()
@@ -125,7 +127,10 @@
  Mir::OrientationAngle MirSurfaceItem::orientationAngle() const
+ {
--    if (m_qmlSurface) {
++    if (m_orientationAngle) {
++        Q_ASSERT(!m_qmlSurface);
++        return *m_orientationAngle;
++    } else if (m_qmlSurface) {
          return m_qmlSurface->orientationAngle();
      } else {
          return Mir::Angle0;
@@ -134,16 +139,24 @@
  void MirSurfaceItem::setOrientationAngle(Mir::OrientationAngle angle)
+ {
--    if (!m_qmlSurface)
--        return;
--
--    if (m_qmlSurface->orientationAngle() == angle)
--        return;
--
--    m_qmlSurface->setOrientationAngle(angle);
--
--    QQmlProperty orientationProp(m_qmlItem, "orientationAngle");
--    orientationProp.write(QVariant::fromValue(m_qmlSurface->orientationAngle()));
++    DEBUG_MSG(angle);
++
++    if (m_qmlSurface) {
++        Q_ASSERT(!m_orientationAngle);
++        m_qmlSurface->setOrientationAngle(angle);
++    } else if (!m_orientationAngle) {
++        m_orientationAngle = new Mir::OrientationAngle;
++        *m_orientationAngle = angle;
++        Q_EMIT orientationAngleChanged(angle);
++    } else if (*m_orientationAngle != angle) {
++        *m_orientationAngle = angle;
++        Q_EMIT orientationAngleChanged(angle);
++    }
++
++    if (m_qmlItem) {
++        QQmlProperty orientationProp(m_qmlItem, "orientationAngle");
++        orientationProp.write(QVariant::fromValue(orientationAngle()));
++    }
+ }
  void MirSurfaceItem::updateScreenshot(QUrl screenshotUrl)
@@ -175,6 +188,11 @@
          QQmlProperty screenshotSource(m_qmlItem, "screenshotSource");
          screenshotSource.write(QVariant::fromValue(m_qmlSurface->screenshotUrl()));
+     }
++
++    {
++        QQmlProperty orientationProp(m_qmlItem, "orientationAngle");
++        orientationProp.write(QVariant::fromValue(orientationAngle()));
++    }
+ }
  void MirSurfaceItem::touchEvent(QTouchEvent * event)
@@ -255,7 +273,16 @@
          updateSurfaceSize();
          updateMirSurfaceVisibility();
--        connect(m_qmlSurface, &MirSurface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);
++        if (m_orientationAngle) {
++            m_qmlSurface->setOrientationAngle(*m_orientationAngle);
++            connect(m_qmlSurface, &MirSurfaceInterface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);
++            delete m_orientationAngle;
++            m_orientationAngle = nullptr;
++        } else {
++            connect(m_qmlSurface, &MirSurfaceInterface::orientationAngleChanged, this, &MirSurfaceItem::orientationAngleChanged);
++            Q_EMIT orientationAngleChanged(m_qmlSurface->orientationAngle());
++        }
++
          connect(m_qmlSurface, &MirSurface::screenshotUrlChanged, this, &MirSurfaceItem::updateScreenshot);
          connect(m_qmlSurface, &MirSurface::liveChanged, this, &MirSurfaceItem::liveChanged);
          connect(m_qmlSurface, &MirSurface::stateChanged, this, &MirSurfaceItem::surfaceStateChanged);
 === modified file 'tests/mocks/Unity/Application/MirSurfaceItem.h'
 --- tests/mocks/Unity/Application/MirSurfaceItem.h	2016-05-09 08:54:11 +0000
 +++ tests/mocks/Unity/Application/MirSurfaceItem.h	2016-06-22 20:20:30 +0000
@@ -117,6 +117,8 @@
      bool m_consumesInput;
++    Mir::OrientationAngle *m_orientationAngle;
++
      int m_surfaceWidth;
      int m_surfaceHeight;
 === modified file 'tests/qmltests/Stages/tst_SpreadDelegate.qml'
 --- tests/qmltests/Stages/tst_SpreadDelegate.qml	2016-04-08 18:30:34 +0000
 +++ tests/qmltests/Stages/tst_SpreadDelegate.qml	2016-06-22 20:20:30 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright 2014-2015 Canonical Ltd.
++ * Copyright 2014-2016 Canonical Ltd.
+  *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
@@ -132,10 +132,12 @@
                  property int value: selectedIndex * 90
+             }
              Button {
++                id: matchShellButton
                  text: "matchShellOrientation()"
                  onClicked: { spreadDelegateLoader.item.matchShellOrientation(); }
+             }
              Button {
++                id: animateToShellButton
                  text: "animateToShellOrientation()"
                  onClicked: { spreadDelegateLoader.item.animateToShellOrientation(); }
+             }
@@ -197,6 +199,77 @@
+         }
++        function waitUntilAppWindowIsFullyLoaded() {
++            var appWindowStateGroup = findInvisibleChild(spreadDelegate, "applicationWindowStateGroup");
++            tryCompareFunction(function() { return appWindowStateGroup.state === "surface" }, true);
++            waitUntilTransitionsEnd(appWindowStateGroup);
++
++            var priv = findInvisibleChild(spreadDelegate, "spreadDelegatePriv");
++            verify(priv);
++            tryCompare(priv, "startingUp", false);
++        }
++
++        function rotateShellTo(angle) {
++            shellOrientationAngleSelector.selectedIndex = angle / 90;
++        }
++
++        function waitUntilRotationAnimationStops() {
++            var orientationChangeAnimation = findInvisibleChild(spreadDelegate, "orientationChangeAnimation");
++            verify(orientationChangeAnimation);
++            tryCompare(orientationChangeAnimation, "running", false);
++        }
++
++        function checkAppWindowTransformationMatchesRotation(appWindow, angle) {
++
++            var topLeftX = 0;
++            var topLeftY = 0;
++            var bottomRightX = 0;
++            var bottomRightY = 0;
++
++            switch (angle) {
++            case 0:
++                topLeftX = 0;
++                topLeftY = 0;
++                bottomRightX = fakeShell.shortestDimension;
++                bottomRightY = fakeShell.longestDimension;
++                break;
++            case 90:
++                topLeftX = fakeShell.shortestDimension;
++                topLeftY = 0;
++                bottomRightX = 0;
++                bottomRightY = fakeShell.longestDimension;
++                break;
++            default:
++                // TODO implement 180 and 270 once we need them
++                verify(false);
++            }
++
++            var appWindowTopLeftInRootCoords = appWindow.mapToItem(root, 0, 0);
++
++            if (appWindowTopLeftInRootCoords.x !== topLeftX) {
++                qtest_fail("appWindow topLeft.x ("+appWindowTopLeftInRootCoords.x+")"
++                           +" doesn't match expectations ("+topLeftX+").", 1);
++            }
++            if (appWindowTopLeftInRootCoords.y !== topLeftY) {
++                qtest_fail("appWindow topLeft.y ("+appWindowTopLeftInRootCoords.y+")"
++                           +" doesn't match expectations ("+topLeftY+").", 1);
++            }
++
++            var appWindowBottomRightInRootCoords = appWindow.mapToItem(root, appWindow.width,
++                                                                             appWindow.height);
++            compare(appWindowBottomRightInRootCoords.x, bottomRightX);
++            compare(appWindowBottomRightInRootCoords.y, bottomRightY);
++
++            if (appWindowBottomRightInRootCoords.x !== bottomRightX) {
++                qtest_fail("appWindow bottomRight.x ("+appWindowBottomRightInRootCoords.x+")"
++                           +" doesn't match expectations ("+bottomRightX+").", 1);
++            }
++            if (appWindowBottomRightInRootCoords.y !== bottomRightY) {
++                qtest_fail("appWindow bottomRight.y ("+appWindowBottomRightInRootCoords.y+")"
++                           +" doesn't match expectations ("+bottomRightY+").", 1);
++            }
++        }
++
          function test_swipeToClose_data() {
              return [
                  {tag: "swipeToClose=true closeable=true -> appWindow moves away",
@@ -278,12 +351,12 @@
          function test_keepsSceneTransformationWhenShellRotates(data) {
              loadWithGalleryApp.clicked();
++            waitUntilAppWindowIsFullyLoaded();
++
              var appWindowWithShadow = findChild(spreadDelegate, "appWindowWithShadow");
              verify(appWindowWithShadow);
--            // Wait until it reaches the state we are interested on.
--            // It begins with "startingUp"
--            tryCompare(appWindowWithShadow, "state", "keepSceneRotation");
++            compare(appWindowWithShadow.state, "keepSceneRotation");
              shellOrientationAngleSelector.selectedIndex = data.selectedIndex;
@@ -293,14 +366,7 @@
              // and scene transformation must be the identity (ie, no rotation or translation)
--            var pointInDelegateCoords = appWindowWithShadow.mapToItem(root, 0, 0);
--            compare(pointInDelegateCoords.x, 0);
--            compare(pointInDelegateCoords.y, 0);
--
--            pointInDelegateCoords = appWindowWithShadow.mapToItem(root,
--                    fakeShell.shortestDimension, fakeShell.longestDimension);
--            compare(pointInDelegateCoords.x, fakeShell.shortestDimension);
--            compare(pointInDelegateCoords.y, fakeShell.longestDimension);
++            checkAppWindowTransformationMatchesRotation(appWindowWithShadow, 0);
+         }
          function waitForCloseAnimationToFinish() {
@@ -316,5 +382,42 @@
              spreadDelegateLoader.item.highlightShown = true;
              tryCompare(highlightRect, "visible", true)
+         }
++
++        /*
++            Checks that the ApplicationWindow position, size and rotation is correct after
++            a sequence of shell rotations folowed by rotations (immediate or not) to match them
++         */
++        function test_animateToShellThenMatchShell() {
++            loadWithGalleryApp.clicked();
++            waitUntilAppWindowIsFullyLoaded();
++
++            var appWindowWithShadow = findChild(spreadDelegate, "appWindowWithShadow");
++            verify(appWindowWithShadow);
++
++            // appWindow transformation is 0 relative to display
++            checkAppWindowTransformationMatchesRotation(appWindowWithShadow, 0);
++
++            rotateShellTo(90);
++
++            // appWindow transformation remains 0 relative to display
++            checkAppWindowTransformationMatchesRotation(appWindowWithShadow, 0);
++
++            animateToShellButton.clicked();
++            waitUntilRotationAnimationStops();
++
++            // appWindow transformation is now 90 relative to display, just like shell
++            checkAppWindowTransformationMatchesRotation(appWindowWithShadow, 90);
++
++            rotateShellTo(0);
++
++            // appWindow transformation is remains 90 relative to display.
++            checkAppWindowTransformationMatchesRotation(appWindowWithShadow, 90);
++
++            matchShellButton.clicked();
++
++            // appWindow transformation is back to 0 relative to display, just like shell
++            checkAppWindowTransformationMatchesRotation(appWindowWithShadow, 0);
++
++        }
+     }
+ }