Enable Tab Dragging Tests with Linux and Ash

chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.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_interactive_uitest.h"
 
+#include <algorithm>
+
 #include "ash/wm/window_state.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_iterator.h"
@@ skipping 24 matching lines @@
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #endif
 
 #if defined(USE_ASH)
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/shell.h"
 #include "ash/test/cursor_manager_test_api.h"
 #include "ash/wm/coordinate_conversion.h"
-#include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/window_event_dispatcher.h"
 #endif
 
 using content::WebContents;
 
 namespace test {
@@ skipping 265 matching lines @@
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   Tab* tab1 = tab_strip->tab_at(1);
   gfx::Point tab_1_center(tab1->width() / 2, tab1->height() / 2);
 
   ui::GestureEvent gesture_begin(ui::ET_GESTURE_BEGIN, tab_1_center.x(),
       tab_1_center.x(), 0, base::TimeDelta(),
       ui::GestureEventDetails(ui::ET_GESTURE_BEGIN, 0.0f, 0.0f), 0);
   tab_strip->MaybeStartDrag(tab1, gesture_begin,
     tab_strip->GetSelectionModel());
-  //tab_strip->tab_at(1)->OnGestureEvent(&gesture_begin);
   EXPECT_TRUE(TabDragController::IsActive());
 
   ui::GestureEvent gesture_end(ui::ET_GESTURE_END, tab_1_center.x(),
       tab_1_center.x(), 0, base::TimeDelta(),
       ui::GestureEventDetails(ui::ET_GESTURE_END, 0.0f, 0.0f), 0);
   tab_strip->OnGestureEvent(&gesture_end);
   EXPECT_FALSE(TabDragController::IsActive());
   EXPECT_FALSE(tab_strip->IsDragSessionActive());
 }
 
 #endif
 
 class DetachToBrowserTabDragControllerTest
     : public TabDragControllerTest,
       public ::testing::WithParamInterface<const char*> {
  public:
   DetachToBrowserTabDragControllerTest() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     if (!docked_windows_enabled()) {
       CommandLine::ForCurrentProcess()->AppendSwitch(
           ash::switches::kAshDisableDockedWindows);
     }
 #endif
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_.reset(new aura::test::EventGenerator(
                                ash::Shell::GetPrimaryRootWindow()));
 #endif
   }
 
+  virtual void TearDownOnMainThread() OVERRIDE {
+#if defined(OS_CHROMEOS)
+    event_generator_.reset();
+#endif
+  }

[pkotwicz, 2014/05/28 15:00:33]

Can this new code be removed?

[jonross, 2014/05/28 15:45:13]

Done.

+
   InputSource input_source() const {
     return strstr(GetParam(), "mouse") ?
         INPUT_SOURCE_MOUSE : INPUT_SOURCE_TOUCH;
   }
 
   bool docked_windows_enabled() const {
     return (strstr(GetParam(), "docked") != NULL);
   }
 
   // Set root window from a point in screen coordinates
   void SetEventGeneratorRootWindow(const gfx::Point& point) {
     if (input_source() == INPUT_SOURCE_MOUSE)
       return;
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_.reset(new aura::test::EventGenerator(
         new ScreenEventGeneratorDelegate(ash::wm::GetRootWindowAt(point))));
 #endif
   }
 
   // The following methods update one of the mouse or touch input depending upon
   // the InputSource.
   bool PressInput(const gfx::Point& location) {
     if (input_source() == INPUT_SOURCE_MOUSE) {
       return ui_test_utils::SendMouseMoveSync(location) &&
           ui_test_utils::SendMouseEventsSync(
               ui_controls::LEFT, ui_controls::DOWN);
     }
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_->set_current_location(location);
     event_generator_->PressTouch();
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool PressInput2() {
     // Second touch input is only used for touch sequence tests.
     EXPECT_EQ(INPUT_SOURCE_TOUCH, input_source());
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_->set_current_location(
         event_generator_->current_location());
     event_generator_->PressTouchId(1);
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool DragInputTo(const gfx::Point& location) {
     if (input_source() == INPUT_SOURCE_MOUSE)
       return ui_test_utils::SendMouseMoveSync(location);
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_->MoveTouch(location);
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool DragInputToAsync(const gfx::Point& location) {
     if (input_source() == INPUT_SOURCE_MOUSE)
       return ui_controls::SendMouseMove(location.x(), location.y());
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_->MoveTouch(location);
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool DragInputToNotifyWhenDone(int x,
                                  int y,
                                  const base::Closure& task) {
     if (input_source() == INPUT_SOURCE_MOUSE)
       return ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     base::MessageLoop::current()->PostTask(FROM_HERE, task);
     event_generator_->MoveTouch(gfx::Point(x, y));
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool DragInputToDelayedNotifyWhenDone(int x,
                                         int y,
                                         const base::Closure& task,
                                         base::TimeDelta delay) {
     if (input_source() == INPUT_SOURCE_MOUSE)
       return ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     base::MessageLoop::current()->PostDelayedTask(FROM_HERE, task, delay);
     event_generator_->MoveTouch(gfx::Point(x, y));
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool DragInput2ToNotifyWhenDone(int x,
                                  int y,
                                  const base::Closure& task) {
     if (input_source() == INPUT_SOURCE_MOUSE)
       return ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     base::MessageLoop::current()->PostTask(FROM_HERE, task);
     event_generator_->MoveTouchId(gfx::Point(x, y), 1);
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool ReleaseInput() {
     if (input_source() == INPUT_SOURCE_MOUSE) {
       return ui_test_utils::SendMouseEventsSync(
               ui_controls::LEFT, ui_controls::UP);
     }
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_->ReleaseTouch();
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool ReleaseInput2() {
     if (input_source() == INPUT_SOURCE_MOUSE) {
       return ui_test_utils::SendMouseEventsSync(
               ui_controls::LEFT, ui_controls::UP);
     }
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
     event_generator_->ReleaseTouchId(1);
 #else
     NOTREACHED();
 #endif
     return true;
   }
 
   bool ReleaseMouseAsync() {
     return input_source() == INPUT_SOURCE_MOUSE &&
         ui_controls::SendMouseEvents(ui_controls::LEFT, ui_controls::UP);
@@ skipping 14 matching lines @@
     }
   }
 
   void AddBlankTabAndShow(Browser* browser) {
     InProcessBrowserTest::AddBlankTabAndShow(browser);
   }
 
   Browser* browser() const { return InProcessBrowserTest::browser(); }
 
  private:
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
   scoped_ptr<aura::test::EventGenerator> event_generator_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(DetachToBrowserTabDragControllerTest);
 };
 
 // Creates a browser with two tabs, drags the second to the first.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest, DragInSameWindow) {
   // TODO(sky): this won't work with touch as it requires a long press.
   if (input_source() == INPUT_SOURCE_TOUCH) {
@@ skipping 94 matching lines @@
   EXPECT_FALSE(tab_strip2->GetWidget()->HasCapture());
 }
 
 namespace {
 
 void DetachToOwnWindowStep2(DetachToBrowserTabDragControllerTest* test) {
   if (test->input_source() == INPUT_SOURCE_TOUCH)
     ASSERT_TRUE(test->ReleaseInput());
 }
 
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
+#if defined(OS_CHROMEOS)
 bool IsWindowPositionManaged(aura::Window* window) {
   return ash::wm::GetWindowState(window)->window_position_managed();
 }
 bool HasUserChangedWindowPositionOrSize(aura::Window* window) {
   return ash::wm::GetWindowState(window)->bounds_changed_by_user();
 }
 #else
 bool IsWindowPositionManaged(gfx::NativeWindow window) {
   return true;
 }
@@ skipping 246 matching lines @@
   Browser* new_browser = browser_list->get(1);
   // This ends up closing the source window.
   delete tab;
   // Cancel the drag.
   ui_controls::SendKeyPress(new_browser->window()->GetNativeWindow(),
                             ui::VKEY_ESCAPE, false, false, false, false);
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_LINUX)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
 #define MAYBE_DeleteSourceDetached DISABLED_DeleteSourceDetached
 #else
 #define MAYBE_DeleteSourceDetached DeleteSourceDetached
 #endif
 // Detaches a tab and while detached deletes a tab from the source so that the
 // source window closes then presses escape to cancel the drag.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        MAYBE_DeleteSourceDetached) {
@@ skipping 29 matching lines @@
 void PressEscapeWhileDetachedStep2(const BrowserList* browser_list) {
   ASSERT_EQ(2u, browser_list->size());
   Browser* new_browser = browser_list->get(1);
   ui_controls::SendKeyPress(
       new_browser->window()->GetNativeWindow(), ui::VKEY_ESCAPE, false, false,
       false, false);
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_LINUX)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
 #define MAYBE_PressEscapeWhileDetached DISABLED_PressEscapeWhileDetached
 #else
 #define MAYBE_PressEscapeWhileDetached PressEscapeWhileDetached
 #endif
 // This is disabled until NativeViewHost::Detach really detaches.
 // Detaches a tab and while detached presses escape to revert the drag.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        MAYBE_PressEscapeWhileDetached) {
@@ skipping 352 matching lines @@
     const BrowserList* browser_list) {
   ASSERT_TRUE(TabDragController::IsActive());
   ASSERT_EQ(2u, browser_list->size());
 
   // Add another tab. This should trigger exiting the nested loop.
   test->AddBlankTabAndShow(browser_list->GetLastActive());
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
+#if defined(OS_CHROMEOS) || defined(OS_LINUX)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
 #define MAYBE_CancelOnNewTabWhenDragging DISABLED_CancelOnNewTabWhenDragging
 #else
 #define MAYBE_CancelOnNewTabWhenDragging CancelOnNewTabWhenDragging
 #endif
 // Adds another tab, detaches into separate window, adds another tab and
 // verifies the run loop ends.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        MAYBE_CancelOnNewTabWhenDragging) {
@@ skipping 14 matching lines @@
   // Should be two windows and not dragging.
   ASSERT_FALSE(TabDragController::IsActive());
   ASSERT_EQ(2u, native_browser_list->size());
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     EXPECT_FALSE(GetIsDragged(*it));
     // Should not be maximized
     EXPECT_FALSE(it->window()->IsMaximized());
   }
 }
 
-#if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
-
+#if defined(OS_CHROMEOS)
+// TODO(sky,sad): A number of tests below are disabled as they fail due to
+// resize locks with a real compositor. crbug.com/331924
 namespace {
 
 void DragInMaximizedWindowStep2(DetachToBrowserTabDragControllerTest* test,
                                 Browser* browser,
                                 TabStrip* tab_strip,
                                 const BrowserList* browser_list) {
   // There should be another browser.
   ASSERT_EQ(2u, browser_list->size());
   Browser* new_browser = browser_list->get(1);
   EXPECT_NE(browser, new_browser);
   ASSERT_TRUE(new_browser->window()->IsActive());
   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
 
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
 
   // Both windows should be visible.
   EXPECT_TRUE(tab_strip->GetWidget()->IsVisible());
   EXPECT_TRUE(tab_strip2->GetWidget()->IsVisible());
 
   // Stops dragging.
   ASSERT_TRUE(test->ReleaseInput());
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DragInMaximizedWindow DISABLED_DragInMaximizedWindow
-#else
-#define MAYBE_DragInMaximizedWindow DragInMaximizedWindow
-#endif
 // Creates a browser with two tabs, maximizes it, drags the tab out.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
-                       MAYBE_DragInMaximizedWindow) {
+                       DISABLED_DragInMaximizedWindow) {
   AddTabAndResetBrowser(browser());
   browser()->window()->Maximize();
 
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
@@ skipping 63 matching lines @@
 void DragSingleTabToSeparateWindowInSecondDisplayStep2(
     DetachToBrowserTabDragControllerTest* test,
     const gfx::Point& target_point) {
   ASSERT_TRUE(test->DragInputToNotifyWhenDone(
       target_point.x(), target_point.y(),
       base::Bind(&DragSingleTabToSeparateWindowInSecondDisplayStep3, test)));
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DragSingleTabToSeparateWindowInSecondDisplay \
-  DISABLED_DragSingleTabToSeparateWindowInSecondDisplay
-#else
-#define MAYBE_DragSingleTabToSeparateWindowInSecondDisplay \
-  DragSingleTabToSeparateWindowInSecondDisplay
-#endif
 // Drags from browser to a second display and releases input.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
-                       MAYBE_DragSingleTabToSeparateWindowInSecondDisplay) {
+                       DISABLED_DragSingleTabToSeparateWindowInSecondDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   // Then drag it to the final destination on the second screen.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
@@ skipping 50 matching lines @@
       GetCenterInScreenCoordinates(target_tab_strip->tab_at(0)));
 
   // Move it close to the beginning of the target tabstrip.
   target_point.set_x(
       target_point.x() - target_tab_strip->tab_at(0)->width() / 2 + 10);
   ASSERT_TRUE(test->DragInputToAsync(target_point));
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DragTabToWindowInSeparateDisplay \
-  DISABLED_DragTabToWindowInSeparateDisplay
-#else
-#define MAYBE_DragTabToWindowInSeparateDisplay DragTabToWindowInSeparateDisplay
-#endif
 // Drags from browser to another browser on a second display and releases input.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
-                       MAYBE_DragTabToWindowInSeparateDisplay) {
+                       DISABLED_DragTabToWindowInSeparateDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Create another browser.
   Browser* browser2 = CreateBrowser(browser()->profile());
   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   ResetIDs(browser2->tab_strip_model(), 100);
 
   // Move the second browser to the second display.
@@ skipping 27 matching lines @@
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
 
   // Both windows should not be maximized
   EXPECT_FALSE(browser()->window()->IsMaximized());
   EXPECT_FALSE(browser2->window()->IsMaximized());
 }
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DragTabToWindowOnSecondDisplay \
-  DISABLED_DragTabToWindowOnSecondDisplay
-#else
-#define MAYBE_DragTabToWindowOnSecondDisplay DragTabToWindowOnSecondDisplay
-#endif
 // Drags from browser to another browser on a second display and releases input.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
-                       MAYBE_DragTabToWindowOnSecondDisplay) {
+                       DISABLED_DragTabToWindowOnSecondDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Create another browser.
   Browser* browser2 = CreateBrowser(browser()->profile());
   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   ResetIDs(browser2->tab_strip_model(), 100);
 
   // Move both browsers to the second display.
@@ skipping 39 matching lines @@
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
 
   // Both windows should not be maximized
   EXPECT_FALSE(browser()->window()->IsMaximized());
   EXPECT_FALSE(browser2->window()->IsMaximized());
 }
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DragMaxTabToNonMaxWindowInSeparateDisplay \
-  DISABLED_DragMaxTabToNonMaxWindowInSeparateDisplay
-#else
-#define MAYBE_DragMaxTabToNonMaxWindowInSeparateDisplay \
-  DragMaxTabToNonMaxWindowInSeparateDisplay
-#endif
 // Drags from a maximized browser to another non-maximized browser on a second
 // display and releases input.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
-                       MAYBE_DragMaxTabToNonMaxWindowInSeparateDisplay) {
+                       DISABLED_DragMaxTabToNonMaxWindowInSeparateDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   browser()->window()->Maximize();
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Create another browser on the second display.
   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   ASSERT_EQ(2u, roots.size());
   aura::Window* first_root = roots[0];
   aura::Window* second_root = roots[1];
   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
       second_root).work_area();
-  work_area.Inset(20,20,20,60);
+  work_area.Inset(20, 20, 20, 60);
   Browser::CreateParams params(browser()->profile(),
                                browser()->host_desktop_type());
   params.initial_show_state = ui::SHOW_STATE_NORMAL;
   params.initial_bounds = work_area;
   Browser* browser2 = new Browser(params);
   AddBlankTabAndShow(browser2);
 
   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   ResetIDs(browser2->tab_strip_model(), 100);
 
@@ skipping 30 matching lines @@
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
 
   // Source browser should still be maximized, target should not
   EXPECT_TRUE(browser()->window()->IsMaximized());
   EXPECT_FALSE(browser2->window()->IsMaximized());
 }
 
-// Immersive fullscreen is Ash only.  However, Windows Ash does not support
-// multiple displays.
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DragTabToImmersiveBrowserOnSeparateDisplay \
-  DISABLED_DragTabToImmersiveBrowserOnSeparateDisplay
 // Drags from a restored browser to an immersive fullscreen browser on a
 // second display and releases input.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
-                       MAYBE_DragTabToImmersiveBrowserOnSeparateDisplay) {
+                       DISABLED_DragTabToImmersiveBrowserOnSeparateDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Create another browser.
   Browser* browser2 = CreateBrowser(browser()->profile());
   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   ResetIDs(browser2->tab_strip_model(), 100);
 
   // Move the second browser to the second display.
@@ skipping 52 matching lines @@
   // The first browser window should not be in immersive fullscreen.
   // browser2 should still be in immersive fullscreen, but the top chrome should
   // no longer be revealed.
   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser());
   EXPECT_FALSE(browser_view->immersive_mode_controller()->IsEnabled());
 
   EXPECT_TRUE(immersive_controller2->IsEnabled());
   EXPECT_FALSE(immersive_controller2->IsRevealed());
   EXPECT_TRUE(tab_strip2->IsImmersiveStyle());
 }
-#endif  // OS_CHROMEOS
 
 // Subclass of DetachToBrowserTabDragControllerTest that
 // creates multiple displays with different device scale factors.
 class DifferentDeviceScaleFactorDisplayTabDragControllerTest
     : public DetachToBrowserTabDragControllerTest {
  public:
   DifferentDeviceScaleFactorDisplayTabDragControllerTest() {}
   virtual ~DifferentDeviceScaleFactorDisplayTabDragControllerTest() {}
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
@@ skipping 59 matching lines @@
   } else {
     // Finishes a serise of CursorDeviceScaleFactorStep calls and ends drag.
     EXPECT_EQ(1.0f, test->GetCursorDeviceScaleFactor());
     ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
         ui_controls::LEFT, ui_controls::UP));
   }
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_CursorDeviceScaleFactor DISABLED_CursorDeviceScaleFactor
-#else
-#define MAYBE_CursorDeviceScaleFactor CursorDeviceScaleFactor
-#endif
 // Verifies cursor's device scale factor is updated when a tab is moved across
 // displays with different device scale factors (http://crbug.com/154183).
 IN_PROC_BROWSER_TEST_P(DifferentDeviceScaleFactorDisplayTabDragControllerTest,
-                       MAYBE_CursorDeviceScaleFactor) {
+                       DISABLED_CursorDeviceScaleFactor) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move the second browser to the second display.
   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   ASSERT_EQ(2u, roots.size());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
@@ skipping 70 matching lines @@
             new_browser->window()->GetNativeWindow()->GetRootWindow());
 
   ASSERT_TRUE(test->DragTabAndExecuteTaskWhenDone(
       final_destination,
       base::Bind(&CancelDragTabToWindowInSeparateDisplayStep3,
                  tab_strip, browser_list)));
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS) || defined(OS_LINUX)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_CancelDragTabToWindowIn2ndDisplay \
-  DISABLED_CancelDragTabToWindowIn2ndDisplay
-#else
-#define MAYBE_CancelDragTabToWindowIn2ndDisplay \
-  CancelDragTabToWindowIn2ndDisplay
-#endif
 // Drags from browser to a second display and releases input.
 IN_PROC_BROWSER_TEST_F(
     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest,
-    MAYBE_CancelDragTabToWindowIn2ndDisplay) {
+    DISABLED_CancelDragTabToWindowIn2ndDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Move the second browser to the second display.
   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   ASSERT_EQ(2u, roots.size());
   gfx::Point final_destination =
@@ skipping 14 matching lines @@
   ASSERT_EQ(1u, native_browser_list->size());
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Release the mouse
   ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
       ui_controls::LEFT, ui_controls::UP));
 }
 
-#if defined(OS_CHROMEOS) || defined(OS_LINUX)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_CancelDragTabToWindowIn1stDisplay \
-  DISABLED_CancelDragTabToWindowIn1stDisplay
-#else
-#define MAYBE_CancelDragTabToWindowIn1stDisplay \
-  CancelDragTabToWindowIn1stDisplay
-#endif
 // Drags from browser from a second display to primary and releases input.
 IN_PROC_BROWSER_TEST_F(
     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest,
-    MAYBE_CancelDragTabToWindowIn1stDisplay) {
+    DISABLED_CancelDragTabToWindowIn1stDisplay) {
   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   ASSERT_EQ(2u, roots.size());
 
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   EXPECT_EQ(roots[0], browser()->window()->GetNativeWindow()->GetRootWindow());
 
@@ skipping 35 matching lines @@
   ASSERT_TRUE(TabDragController::IsActive());
   ASSERT_EQ(2u, test->native_browser_list->size());
   Browser* new_browser = test->native_browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
 
   ASSERT_TRUE(test->PressInput2());
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_PressSecondFingerWhileDetached DISABLED_PressSecondFingerWhileDetached
-#else
-#define MAYBE_PressSecondFingerWhileDetached PressSecondFingerWhileDetached
-#endif
 // Detaches a tab and while detached presses a second finger.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTestTouch,
-                       MAYBE_PressSecondFingerWhileDetached) {
+                       DISABLED_PressSecondFingerWhileDetached) {
   gfx::Rect bounds(browser()->window()->GetBounds());
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
@@ skipping 42 matching lines @@
   ASSERT_TRUE(test->DragInputToNotifyWhenDone(
       target_point.x(), target_point.y(),
       base::Bind(&DetachToDockedWindowNextStep,
                  test,
                  gfx::Point(target_point.x(), 1 + target_point.y()),
                  iteration - 1)));
 }
 
 }  // namespace
 
-#if defined(OS_CHROMEOS)
-// TODO(sky,sad): Disabled as it fails due to resize locks with a real
-// compositor. crbug.com/331924
-#define MAYBE_DetachToDockedWindowFromMaximizedWindow \
-  DISABLED_DetachToDockedWindowFromMaximizedWindow
-#else
-#define MAYBE_DetachToDockedWindowFromMaximizedWindow \
-  DetachToDockedWindowFromMaximizedWindow
-#endif
 // Drags from browser to separate window, docks that window and releases mouse.
 IN_PROC_BROWSER_TEST_P(DetachToDockedTabDragControllerTest,
-                       MAYBE_DetachToDockedWindowFromMaximizedWindow) {
+                       DISABLED_DetachToDockedWindowFromMaximizedWindow) {
   // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   // compositor. crbug.com/331924
   if (docked_windows_enabled()) {
     VLOG(1) << "Test is DISABLED for docked windows.";
     return;
   }
 
   // Maximize the initial browser window.
   browser()->window()->Maximize();
   ASSERT_TRUE(browser()->window()->IsMaximized());
@@ skipping 49 matching lines @@
     // The new window should be docked and not snapped if docking is allowed.
     EXPECT_TRUE(window_state->IsDocked());
     EXPECT_FALSE(window_state->IsSnapped());
   } else {
     // The new window should be snapped and not docked if docking is disabled.
     EXPECT_FALSE(window_state->IsDocked());
     EXPECT_TRUE(window_state->IsSnapped());
   }
 }
 
-
-#endif
+#endif  // OS_CHROMEOS
 
 #if defined(USE_ASH) && defined(OS_CHROMEOS)  // TODO(win_ash,linux_ash)
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserInSeparateDisplayTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DifferentDeviceScaleFactorDisplayTabDragControllerTest,
                         ::testing::Values("mouse"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToDockedTabDragControllerTest,
                         ::testing::Values("mouse", "mouse docked"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTestTouch,
                         ::testing::Values("touch", "touch docked"));
-#elif defined(USE_ASH) && !defined(OS_LINUX) // TODO(linux_ash)
+#elif defined(USE_ASH)
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse"));
 #endif