Fix crash when dragging a half width window to split view from overivew mode

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/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;
+}
+
+}  // 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),
       separator_position_(0),
       weak_factory_(this) {
@@ skipping 73 matching lines @@
   wm::ActivateWindow(replace_with);
   window->SetTransform(gfx::Transform());
 }
 
 void SplitViewController::DeactivateSplitMode() {
   CHECK_NE(SCROLLING, state_);
   state_ = INACTIVE;
   left_window_ = right_window_ = NULL;
 }
 
+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) {
   if  (!left_window_)
     return;
   CHECK(right_window_);
   gfx::Transform left_transform;
   gfx::Transform right_transform;
   int container_width = container_->GetBoundsInScreen().width();
   if (state_ == ACTIVE) {
-    // This method should only be called once in ACTIVE state when
-    // the left and rightwindows are still full screen and need to be resized.
-    CHECK_EQ(left_window_->bounds().width(), container_width);
-    CHECK_EQ(right_window_->bounds().width(), container_width);
     // Windows should be resized via an animation when entering the ACTIVE
     // state.
     CHECK(animate);
     // We scale the windows here, but when the animation finishes, we reset
     // the scaling and update the window bounds to the proper size - see
     // OnAnimationCompleted().
-    left_transform.Scale(.5, 1);
-    right_transform.Scale(.5, 1);
-    right_transform.Translate(container_width, 0);
+    left_transform = GetTargetTransformForBoundsAnimation(
+        left_window_->bounds(), GetLeftTargetBounds());
+    right_transform = GetTargetTransformForBoundsAnimation(
+        right_window_->bounds(), GetRightTargetBounds());
   } else {
     left_transform.Translate(separator_position_ - container_width, 0);
     right_transform.Translate(separator_position_, 0);
   }
   left_window_->Show();
   right_window_->Show();
   SetWindowTransform(left_window_, left_transform, animate);
   SetWindowTransform(right_window_, right_transform, animate);
 }
 
@@ skipping 14 matching lines @@
     window->SetTransform(transform);
   }
 }
 
 void SplitViewController::OnAnimationCompleted(aura::Window* window) {
   // Animation can be cancelled when deactivated.
   if (left_window_ == NULL)
     return;
   DCHECK(window == left_window_ || window == right_window_);
   if (state_ == ACTIVE) {
-    gfx::Rect window_bounds = gfx::Rect(container_->bounds().size());
-    int container_width = window_bounds.width();
-    window_bounds.set_width(container_width / 2);
     window->SetTransform(gfx::Transform());
-    if (window == left_window_) {
-      left_window_->SetBounds(window_bounds);
-    } else {
-      window_bounds.set_x(container_width / 2);
-      right_window_->SetBounds(window_bounds);
-    }
+    if (window == left_window_)
+      left_window_->SetBounds(GetLeftTargetBounds());
+    else
+      right_window_->SetBounds(GetRightTargetBounds());
   } else {
     int container_width = container_->bounds().width();
     window->SetTransform(gfx::Transform());
     if (window == left_window_) {
       if (separator_position_ == 0)
         left_window_->Hide();
       if (state_ == INACTIVE)
         left_window_ = NULL;
     } else {
       if (separator_position_ == container_width)
@@ skipping 76 matching lines @@
 }
 
 bool SplitViewController::CanScroll() {
   // TODO(mfomitchev): return false in vertical orientation, in full screen.
   bool result = (!IsSplitViewModeActive() &&
                  window_list_provider_->GetWindowList().size() >= 2);
   return result;
 }
 
 }  // namespace athena