Revert of Fix crash which occurs when a widget destroys itself as a result of ET_GESTURE_TAP_DOWN

ui/views/widget/widget_unittest.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 <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/aura/client/window_tree_client.h"
-#include "ui/aura/root_window.h"
-#include "ui/aura/test/event_generator.h"
-#include "ui/aura/test/test_window_delegate.h"
-#include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 #include "ui/views/bubble/bubble_delegate.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/views_delegate.h"
-#include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/native_widget_delegate.h"
 #include "ui/views/widget/root_view.h"
-#include "ui/views/widget/widget_deletion_observer.h"
 #include "ui/views/window/dialog_delegate.h"
 #include "ui/views/window/native_frame_view.h"
 
+#if defined(USE_AURA)
+#include "ui/aura/client/aura_constants.h"
+#include "ui/aura/client/window_tree_client.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/test/test_window_delegate.h"
+#include "ui/aura/window.h"
+#include "ui/views/widget/native_widget_aura.h"
 #if !defined(OS_CHROMEOS)
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #endif
+#elif defined(OS_WIN)
+#include "ui/views/widget/native_widget_win.h"
+#endif
 
 #if defined(OS_WIN)
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 namespace views {
 namespace test {
 
 // A view that keeps track of the events it receives, but consumes no events.
 class EventCountView : public View {
@@ skipping 103 matching lines @@
  private:
   void RecordEvent(const ui::Event& event) {
     ++event_count_[event.type()];
   }
 
   std::map<ui::EventType, int> event_count_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCountHandler);
 };
 
-// Class that closes the widget (which ends up deleting it immediately) when the
-// appropriate event is received.
-class CloseWidgetView : public View {
- public:
-  explicit CloseWidgetView(ui::EventType event_type)
-      : event_type_(event_type) {
-  }
-
-  // ui::EventHandler override:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
-    if (event->type() == event_type_) {
-      // Go through NativeWidgetPrivate to simulate what happens if the OS
-      // deletes the NativeWindow out from under us.
-      GetWidget()->native_widget_private()->CloseNow();
-    } else {
-      View::OnEvent(event);
-      if (!event->IsTouchEvent())
-        event->SetHandled();
-    }
-  }
-
- private:
-  const ui::EventType event_type_;
-
-  DISALLOW_COPY_AND_ASSIGN(CloseWidgetView);
-};
-
 ui::WindowShowState GetWidgetShowState(const Widget* widget) {
   // Use IsMaximized/IsMinimized/IsFullScreen instead of GetWindowPlacement
   // because the former is implemented on all platforms but the latter is not.
   return widget->IsFullscreen() ? ui::SHOW_STATE_FULLSCREEN :
       widget->IsMaximized() ? ui::SHOW_STATE_MAXIMIZED :
       widget->IsMinimized() ? ui::SHOW_STATE_MINIMIZED :
       widget->IsActive() ? ui::SHOW_STATE_NORMAL :
                            ui::SHOW_STATE_INACTIVE;
 }
 
@@ skipping 423 matching lines @@
     widget->IsMouseEventsEnabled();
     widget->SetNativeWindowProperty("xx", widget);
     widget->GetNativeWindowProperty("xx");
     widget->GetFocusTraversable();
     widget->GetLayer();
     widget->ReorderNativeViews();
     widget->SetCapture(widget->GetRootView());
     widget->ReleaseCapture();
     widget->HasCapture();
     widget->GetWorkAreaBoundsInScreen();
+    // These three crash with NativeWidgetWin, so I'm assuming we don't need
+    // them to work for the other NativeWidget impls.
+    // widget->CenterWindow(gfx::Size(50, 60));
+    // widget->GetRestoredBounds();
+    // widget->ShowInactive();
+    // widget->Show();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WidgetWithDestroyedNativeViewTest);
 };
 
 TEST_F(WidgetWithDestroyedNativeViewTest, Test) {
   {
     Widget widget;
     Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
@@ skipping 638 matching lines @@
   EXPECT_FALSE(widget.GetNativeView()->IsVisible());
   widget.Show();
   EXPECT_TRUE(widget.GetNativeView()->IsVisible());
 }
 
 // The following code verifies we can correctly destroy a Widget from a mouse
 // enter/exit. We could test move/drag/enter/exit but in general we don't run
 // nested message loops from such events, nor has the code ever really dealt
 // with this situation.
 
+// Class that closes the widget (which ends up deleting it immediately) when the
+// appropriate event is received.
+class CloseWidgetView : public View {
+ public:
+  explicit CloseWidgetView(ui::EventType event_type)
+      : event_type_(event_type) {
+  }
+
+  // View overrides:
+  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE {
+    if (!CloseWidget(event))
+      View::OnMousePressed(event);
+    return true;
+  }
+  virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE {
+    if (!CloseWidget(event))
+      View::OnMouseDragged(event);
+    return true;
+  }
+  virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE {
+    if (!CloseWidget(event))
+      View::OnMouseReleased(event);
+  }
+  virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE {
+    if (!CloseWidget(event))
+      View::OnMouseMoved(event);
+  }
+  virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE {
+    if (!CloseWidget(event))
+      View::OnMouseEntered(event);
+  }
+
+ private:
+  bool CloseWidget(const ui::LocatedEvent& event) {
+    if (event.type() == event_type_) {
+      // Go through NativeWidgetPrivate to simulate what happens if the OS
+      // deletes the NativeWindow out from under us.
+      GetWidget()->native_widget_private()->CloseNow();
+      return true;
+    }
+    return false;
+  }
+
+  const ui::EventType event_type_;
+
+  DISALLOW_COPY_AND_ASSIGN(CloseWidgetView);
+};
+
 // Generates two moves (first generates enter, second real move), a press, drag
 // and release stopping at |last_event_type|.
 void GenerateMouseEvents(Widget* widget, ui::EventType last_event_type) {
   const gfx::Rect screen_bounds(widget->GetWindowBoundsInScreen());
   ui::MouseEvent move_event(ui::ET_MOUSE_MOVED, screen_bounds.CenterPoint(),
                             screen_bounds.CenterPoint(), 0, 0);
   aura::WindowEventDispatcher* dispatcher =
       widget->GetNativeWindow()->GetDispatcher();
   ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move_event);
   if (last_event_type == ui::ET_MOUSE_ENTERED || details.dispatcher_destroyed)
@@ skipping 378 matching lines @@
   set_views_delegate(delegate);  // ViewsTestBase takes ownership.
   scoped_ptr<Widget> widget(new Widget);
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_POPUP);
   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
   EXPECT_TRUE(delegate->on_before_init_called());
   EXPECT_TRUE(delegate->is_top_level());
 }
 
-TEST_F(WidgetTest, WidgetDeleted_InOnMousePressed) {
+// A scumbag View that deletes its owning widget OnMousePressed.
+class WidgetDeleterView : public View {
+ public:
+  WidgetDeleterView() : View() {}
+
+  // Overridden from View.
+  virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE {
+    delete GetWidget();
+    return true;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WidgetDeleterView);
+};
+
+TEST_F(WidgetTest, TestWidgetDeletedInOnMousePressed) {
   Widget* widget = new Widget;
   Widget::InitParams params =
       CreateParams(views::Widget::InitParams::TYPE_POPUP);
+  params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   widget->Init(params);
 
-  widget->SetContentsView(new CloseWidgetView(ui::ET_MOUSE_PRESSED));
+  widget->SetContentsView(new WidgetDeleterView);
 
   widget->SetSize(gfx::Size(100, 100));
   widget->Show();
 
-  aura::test::EventGenerator generator(GetContext(), widget->GetNativeWindow());
-
-  WidgetDeletionObserver deletion_observer(widget);
-  generator.ClickLeftButton();
-  EXPECT_FALSE(deletion_observer.IsWidgetAlive());
+  gfx::Point click_location(45, 15);
+  ui::MouseEvent press(ui::ET_MOUSE_PRESSED, click_location, click_location,
+                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  widget->OnMouseEvent(&press);
 
   // Yay we did not crash!
 }
-
-TEST_F(WidgetTest, WidgetDeleted_InDispatchGestureEvent) {
-  Widget* widget = new Widget;
-  Widget::InitParams params =
-      CreateParams(views::Widget::InitParams::TYPE_POPUP);
-  widget->Init(params);
-
-  widget->SetContentsView(new CloseWidgetView(ui::ET_GESTURE_TAP_DOWN));
-
-  widget->SetSize(gfx::Size(100, 100));
-  widget->Show();
-
-  aura::test::EventGenerator generator(GetContext());
-
-  WidgetDeletionObserver deletion_observer(widget);
-  generator.GestureTapAt(widget->GetWindowBoundsInScreen().CenterPoint());
-  EXPECT_FALSE(deletion_observer.IsWidgetAlive());
-
-  // Yay we did not crash!
-}
 
 // See description of RunGetNativeThemeFromDestructor() for details.
 class GetNativeThemeFromDestructorView : public WidgetDelegateView {
  public:
   GetNativeThemeFromDestructorView() {}
   virtual ~GetNativeThemeFromDestructorView() {
     VerifyNativeTheme();
   }
 
   virtual View* GetContentsView() OVERRIDE {
@@ skipping 664 matching lines @@
   child_widget.Init(child_params);
   child_widget.AddObserver(&observer);
   child_widget.Show();
 
   parent_widget.CloseNow();
 }
 #endif
 
 }  // namespace test
 }  // namespace views