Revert of Reenable Tabdragging tests failing because of IsWindowPositionManaged()

chrome/browser/ui/views/tabs/tab_drag_controller.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 "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/auto_reset.h"
@@ skipping 68 matching lines @@
 // close enough to trigger moving.
 const int kStackedDistance = 36;
 
 // A dragged window is forced to be a bit smaller than maximized bounds during a
 // drag. This prevents the dragged browser widget from getting maximized at
 // creation and makes it easier to drag tabs out of a restored window that had
 // maximized size.
 const int kMaximizedWindowInset = 10;  // DIPs.
 
 #if defined(USE_ASH)
+void SetWindowPositionManaged(gfx::NativeWindow window, bool value) {
+  ash::wm::GetWindowState(window)->set_window_position_managed(value);
+}
+
 // Returns true if |tab_strip| browser window is docked.
 bool IsDockedOrSnapped(const TabStrip* tab_strip) {
   DCHECK(tab_strip);
   ash::wm::WindowState* window_state =
       ash::wm::GetWindowState(tab_strip->GetWidget()->GetNativeWindow());
   return window_state->IsDocked() || window_state->IsSnapped();
 }
 #else
+void SetWindowPositionManaged(gfx::NativeWindow window, bool value) {
+}
+
 bool IsDockedOrSnapped(const TabStrip* tab_strip) {
   return false;
 }
 #endif
 
 #if defined(USE_AURA)
 gfx::NativeWindow GetModalTransient(gfx::NativeWindow window) {
   return wm::GetModalTransient(window);
 }
 #else
@@ skipping 16 matching lines @@
 
 // Adds |x_offset| to all the rectangles in |rects|.
 void OffsetX(int x_offset, std::vector<gfx::Rect>* rects) {
   if (x_offset == 0)
     return;
 
   for (size_t i = 0; i < rects->size(); ++i)
     (*rects)[i].set_x((*rects)[i].x() + x_offset);
 }
 
+// WidgetObserver implementation that resets the window position managed
+// property on Show.
+// We're forced to do this here since BrowserFrameAsh resets the 'window
+// position managed' property during a show and we need the property set to
+// false before WorkspaceLayoutManager sees the visibility change.
+class WindowPositionManagedUpdater : public views::WidgetObserver {
+ public:
+  void OnWidgetVisibilityChanged(views::Widget* widget, bool visible) override {
+    SetWindowPositionManaged(widget->GetNativeWindow(), false);
+  }
+};
+
 // EscapeTracker installs an event monitor and runs a callback when it receives
 // the escape key.
 class EscapeTracker : public ui::EventHandler {
  public:
   explicit EscapeTracker(const base::Closure& callback)
       : escape_callback_(callback),
         event_monitor_(views::EventMonitor::CreateApplicationMonitor(this)) {
   }
 
  private:
@@ skipping 67 matching lines @@
 
 TabDragController::~TabDragController() {
   views::ViewStorage::GetInstance()->RemoveView(old_focused_view_id_);
 
   if (instance_ == this)
     instance_ = NULL;
 
   if (move_loop_widget_) {
     if (added_observer_to_move_loop_widget_)
       move_loop_widget_->RemoveObserver(this);
+    SetWindowPositionManaged(move_loop_widget_->GetNativeWindow(), true);
   }
 
   if (source_tabstrip_)
     GetModel(source_tabstrip_)->RemoveObserver(this);
 
   if (event_source_ == EVENT_SOURCE_TOUCH) {
     TabStrip* capture_tabstrip = attached_tabstrip_ ?
         attached_tabstrip_ : source_tabstrip_;
     capture_tabstrip->GetWidget()->ReleaseCapture();
   }
@@ skipping 359 matching lines @@
     // going to trigger capture lost, which cancels drag.
     attached_tabstrip_->ReleaseDragController();
     target_tabstrip->OwnDragController(this);
     // Disable animations so that we don't see a close animation on aero.
     browser_widget->SetVisibilityChangedAnimationsEnabled(false);
     if (can_release_capture_)
       browser_widget->ReleaseCapture();
     else
       target_tabstrip->GetWidget()->SetCapture(attached_tabstrip_);
 
+    // The window is going away. Since the drag is still on going we don't want
+    // that to effect the position of any windows.
+    SetWindowPositionManaged(browser_widget->GetNativeWindow(), false);
+
 #if !defined(OS_LINUX) || defined(OS_CHROMEOS)
     // EndMoveLoop is going to snap the window back to its original location.
     // Hide it so users don't see this. Hiding a window in Linux aura causes
     // it to lose capture so skip it.
     browser_widget->Hide();
 #endif
     browser_widget->EndMoveLoop();
 
     // Ideally we would always swap the tabs now, but on non-ash Windows, it
     // seems that running the move loop implicitly activates the window when
@@ skipping 419 matching lines @@
       ui::GestureRecognizer::ShouldCancelTouches::DontCancel);
 #endif
 
   Detach(can_release_capture_ ? RELEASE_CAPTURE : DONT_RELEASE_CAPTURE);
 
   dragged_widget->SetVisibilityChangedAnimationsEnabled(false);
   Attach(dragged_browser_view->tabstrip(), gfx::Point());
   AdjustBrowserAndTabBoundsForDrag(last_tabstrip_width,
                                    point_in_screen,
                                    &drag_bounds);
+  WindowPositionManagedUpdater updater;
+  dragged_widget->AddObserver(&updater);
   browser->window()->Show();
+  dragged_widget->RemoveObserver(&updater);
   dragged_widget->SetVisibilityChangedAnimationsEnabled(true);
   // Activate may trigger a focus loss, destroying us.
   {
     base::WeakPtr<TabDragController> ref(weak_factory_.GetWeakPtr());
     browser->window()->Activate();
     if (!ref)
       return;
   }
   RunMoveLoop(drag_offset);
 }
@@ skipping 30 matching lines @@
           drag_offset, move_loop_source, escape_behavior);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::NotificationService::NoDetails());
 
   if (!ref)
     return;
   if (move_loop_widget_) {
     move_loop_widget_->RemoveObserver(this);
-    move_loop_widget_ = nullptr;
+    move_loop_widget_ = NULL;
   }
   is_dragging_window_ = false;
   waiting_for_run_loop_to_exit_ = false;
   if (end_run_loop_behavior_ == END_RUN_LOOP_CONTINUE_DRAGGING) {
     end_run_loop_behavior_ = END_RUN_LOOP_STOP_DRAGGING;
     if (tab_strip_to_attach_to_after_exit_) {
       gfx::Point point_in_screen(GetCursorScreenPoint());
       Detach(DONT_RELEASE_CAPTURE);
       Attach(tab_strip_to_attach_to_after_exit_, point_in_screen);
       // Move the tabs into position.
@@ skipping 219 matching lines @@
 void TabDragController::EndDragImpl(EndDragType type) {
   DCHECK(active_);
   active_ = false;
 
   bring_to_front_timer_.Stop();
   move_stacked_timer_.Stop();
 
   if (is_dragging_window_) {
     waiting_for_run_loop_to_exit_ = true;
 
+    if (type == NORMAL || (type == TAB_DESTROYED && drag_data_.size() > 1)) {
+      SetWindowPositionManaged(GetAttachedBrowserWidget()->GetNativeWindow(),
+                               true);
+    }
+
     // End the nested drag loop.
     GetAttachedBrowserWidget()->EndMoveLoop();
   }
 
   if (type != TAB_DESTROYED) {
     // We only finish up the drag if we were actually dragging. If start_drag_
     // is false, the user just clicked and released and didn't move the mouse
     // enough to trigger a drag.
     if (started_drag_) {
       RestoreFocus();
@@ skipping 390 matching lines @@
                                                      point_in_screen,
                                                      drag_bounds));
   *drag_offset = point_in_screen - new_bounds.origin();
 
   Profile* profile =
       Profile::FromBrowserContext(drag_data_[0].contents->GetBrowserContext());
   Browser::CreateParams create_params(Browser::TYPE_TABBED, profile);
   create_params.initial_bounds = new_bounds;
   Browser* browser = new Browser(create_params);
   is_dragging_new_browser_ = true;
+  SetWindowPositionManaged(browser->window()->GetNativeWindow(), false);
   // If the window is created maximized then the bounds we supplied are ignored.
   // We need to reset them again so they are honored.
   browser->window()->SetBounds(new_bounds);
 
   return browser;
 }
 
 gfx::Point TabDragController::GetCursorScreenPoint() {
 #if defined(USE_ASH)
   if (event_source_ == EVENT_SOURCE_TOUCH &&
@@ skipping 45 matching lines @@
   // TODO(pkotwicz): Fix this properly (crbug.com/358482)
   for (auto* browser : *BrowserList::GetInstance()) {
     if (browser->tab_strip_model()->empty())
       exclude.insert(browser->window()->GetNativeWindow());
   }
 #endif
   base::WeakPtr<TabDragController> ref(weak_factory_.GetWeakPtr());
   *window = window_finder_->GetLocalProcessWindowAtPoint(screen_point, exclude);
   return ref ? Liveness::ALIVE : Liveness::DELETED;
 }