Disable screen rotation when splitview is engaged and only allow splitview in landscape.

athena/wm/split_view_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 "athena/wm/split_view_controller.h"
 
 #include <cmath>
 
+#include "athena/screen/public/screen_manager.h"
 #include "athena/wm/public/window_list_provider.h"
 #include "athena/wm/public/window_manager.h"
 #include "base/bind.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/window_util.h"
 
 namespace athena {
 
 namespace {
 
 // Returns a target transform which is suitable for animating a windows's
 // bounds.
 gfx::Transform GetTargetTransformForBoundsAnimation(const gfx::Rect& from,
                                                     const gfx::Rect& to) {
   gfx::Transform transform;
   transform.Translate(to.x() - from.x(), to.y() - from.y());
   transform.Scale(to.width() / static_cast<float>(from.width()),
                   to.height() / static_cast<float>(from.height()));
   return transform;
 }
 
+bool IsLandscapeOrientation(gfx::Display::Rotation rotation) {
+  return rotation == gfx::Display::ROTATE_0 ||
+         rotation == gfx::Display::ROTATE_180;
+}
+
 }  // namespace
 
 SplitViewController::SplitViewController(
     aura::Window* container,
     WindowListProvider* window_list_provider)
     : state_(INACTIVE),
       container_(container),
       window_list_provider_(window_list_provider),
       left_window_(NULL),
       right_window_(NULL),
@@ skipping 74 matching lines @@
   UpdateLayout(false);
   window->SetTransform(gfx::Transform());
   window->Hide();
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_EQ(ACTIVE, state_);
   state_ = INACTIVE;
   UpdateLayout(false);
   left_window_ = right_window_ = NULL;
+  ScreenManager::Get()->SetRotationLocked(false);
 }
 
 gfx::Rect SplitViewController::GetLeftTargetBounds() {
   gfx::Rect work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
   return gfx::Rect(0, 0, container_->bounds().width() / 2, work_area.height());
 }
 
 gfx::Rect SplitViewController::GetRightTargetBounds() {
   gfx::Rect work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area();
   int container_width = container_->bounds().width();
   return gfx::Rect(
       container_width / 2, 0, container_width / 2, work_area.height());
 }
 
 void SplitViewController::UpdateLayout(bool animate) {
   CHECK(left_window_);
   CHECK(right_window_);
 
+  // Splitview can be activated from SplitViewController::ActivateSplitMode or
+  // SplitViewController::ScrollEnd. Additionally we don't want to rotate the
+  // screen while engaging splitview (i.e. state_ == SCROLLING).
+  ScreenManager::Get()->SetRotationLocked(state_ != INACTIVE);

[mfomitchev, 2014/09/03 15:33:59]

Perhaps we should create a SetState() method and lock/unlock rotation there.
This way the logic would be centralized and we won't be calling
SetRotationLocked when we don't need to.

[flackr, 2014/09/03 16:42:13]

Done.

   if (state_ == INACTIVE && !animate) {
     if (!wm::IsActiveWindow(left_window_))
       left_window_->Hide();
     if (!wm::IsActiveWindow(right_window_))
       right_window_->Hide();
     SetWindowTransforms(gfx::Transform(), gfx::Transform(), false);
     return;
   }
 
   left_window_->Show();
@@ skipping 126 matching lines @@
 }
 
 void SplitViewController::ScrollUpdate(float delta) {
   if (state_ != SCROLLING)
     return;
   UpdateSeparatorPositionFromScrollDelta(delta);
   UpdateLayout(false);
 }
 
 bool SplitViewController::CanScroll() {
-  // TODO(mfomitchev): return false in vertical orientation, in full screen.
+  // TODO(mfomitchev): return false in full screen.
   bool result = (!IsSplitViewModeActive() &&
-                 window_list_provider_->GetWindowList().size() >= 2);
+                 window_list_provider_->GetWindowList().size() >= 2 &&
+                 IsLandscapeOrientation(gfx::Screen::GetNativeScreen()->
+                     GetDisplayNearestWindow(container_).rotation()));
   return result;
 }
 
 }  // namespace athena