Run ContentMain in a browser_test's browser process. This removes duplication of code in the browse…

ui/views/widget/widget_interactive_uitest.cc

 // Copyright (c) 2013 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 "base/basictypes.h"
 #include "base/bind.h"
+#include "base/path_service.h"
 #include "base/run_loop.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/base/ui_base_paths.h"
 #include "ui/gfx/native_widget_types.h"
+#include "ui/gl/gl_surface.h"
 #include "ui/views/test/widget_test.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_delegate.h"
 
 #if !defined(OS_CHROMEOS)
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #endif
 
 #if defined(OS_WIN)
 #include "ui/views/win/hwnd_util.h"
@@ skipping 111 matching lines @@
     return true;
   }
 
   Widget* widget_;
 
   DISALLOW_COPY_AND_ASSIGN(NestedLoopCaptureView);
 };
 
 }  // namespace
 
+class WidgetTestInteractive : public WidgetTest {
+ public:
+  WidgetTestInteractive() {}
+  virtual ~WidgetTestInteractive() {}
+
+  virtual void SetUp() OVERRIDE {
+    gfx::GLSurface::InitializeOneOffForTests();
+    base::FilePath pak_dir;
+    PathService::Get(base::DIR_MODULE, &pak_dir);
+    base::FilePath pak_file;
+    pak_file = pak_dir.Append(FILE_PATH_LITERAL("ui_test.pak"));
+    ui::ResourceBundle::InitSharedInstanceWithPakPath(pak_file);
+    WidgetTest::SetUp();
+  }
+};
+
 #if defined(OS_WIN)
 // Tests whether activation and focus change works correctly in Windows.
 // We test the following:-
 // 1. If the active aura window is correctly set when a top level widget is
 //    created.
 // 2. If the active aura window in widget 1 created above, is set to NULL when
 //    another top level widget is created and focused.
 // 3. On focusing the native platform window for widget 1, the active aura
 //    window for widget 1 should be set and that for widget 2 should reset.
 // TODO(ananta)
 // Discuss with erg on how to write this test for linux x11 aura.
-TEST_F(WidgetTest, DesktopNativeWidgetAuraActivationAndFocusTest) {
+TEST_F(WidgetTestInteractive, DesktopNativeWidgetAuraActivationAndFocusTest) {
   // Create widget 1 and expect the active window to be its window.
   View* contents_view1 = new View;
   contents_view1->SetFocusable(true);
   Widget widget1;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.native_widget = new DesktopNativeWidgetAura(&widget1);
   widget1.Init(init_params);
@@ skipping 35 matching lines @@
   // window.
   contents_view1->RequestFocus();
   ::SetActiveWindow(
       root_window1->GetHost()->GetAcceleratedWidget());
   EXPECT_EQ(activation_client2->GetActiveWindow(),
             reinterpret_cast<aura::Window*>(NULL));
   EXPECT_EQ(activation_client1->GetActiveWindow(), widget1.GetNativeView());
 }
 #endif
 
-TEST_F(WidgetTest, CaptureAutoReset) {
+TEST_F(WidgetTestInteractive, CaptureAutoReset) {
   Widget* toplevel = CreateTopLevelFramelessPlatformWidget();
   View* container = new View;
   toplevel->SetContentsView(container);
 
   EXPECT_FALSE(toplevel->HasCapture());
   toplevel->SetCapture(NULL);
   EXPECT_TRUE(toplevel->HasCapture());
 
   // By default, mouse release removes capture.
   gfx::Point click_location(45, 15);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, click_location, click_location,
                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   toplevel->OnMouseEvent(&release);
   EXPECT_FALSE(toplevel->HasCapture());
 
   // Now a mouse release shouldn't remove capture.
   toplevel->set_auto_release_capture(false);
   toplevel->SetCapture(NULL);
   EXPECT_TRUE(toplevel->HasCapture());
   toplevel->OnMouseEvent(&release);
   EXPECT_TRUE(toplevel->HasCapture());
   toplevel->ReleaseCapture();
   EXPECT_FALSE(toplevel->HasCapture());
 
   toplevel->Close();
   RunPendingMessages();
 }
 
-TEST_F(WidgetTest, ResetCaptureOnGestureEnd) {
+TEST_F(WidgetTestInteractive, ResetCaptureOnGestureEnd) {
   Widget* toplevel = CreateTopLevelFramelessPlatformWidget();
   View* container = new View;
   toplevel->SetContentsView(container);
 
   View* gesture = new GestureCaptureView;
   gesture->SetBounds(0, 0, 30, 30);
   container->AddChildView(gesture);
 
   MouseView* mouse = new MouseView;
   mouse->SetBounds(30, 0, 30, 30);
@@ skipping 35 matching lines @@
   toplevel->OnMouseEvent(&release);
   EXPECT_EQ(1, mouse->pressed());
 
   toplevel->Close();
   RunPendingMessages();
 }
 
 // Checks that if a mouse-press triggers a capture on a different widget (which
 // consumes the mouse-release event), then the target of the press does not have
 // capture.
-TEST_F(WidgetTest, DisableCaptureWidgetFromMousePress) {
+TEST_F(WidgetTestInteractive, DisableCaptureWidgetFromMousePress) {
   // The test creates two widgets: |first| and |second|.
   // The View in |first| makes |second| visible, sets capture on it, and starts
   // a nested loop (like a menu does). The View in |second| terminates the
   // nested loop and closes the widget.
   // The test sends a mouse-press event to |first|, and posts a task to send a
   // release event to |second|, to make sure that the release event is
   // dispatched after the nested loop starts.
 
   Widget* first = CreateTopLevelFramelessPlatformWidget();
   Widget* second = CreateTopLevelFramelessPlatformWidget();
@@ skipping 18 matching lines @@
   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, location, location,
                        ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   first->OnMouseEvent(&press);
   EXPECT_FALSE(first->HasCapture());
   first->Close();
   RunPendingMessages();
 }
 
 // Tests some grab/ungrab events.
 // TODO(estade): can this be enabled now that this is an interactive ui test?
-TEST_F(WidgetTest, DISABLED_GrabUngrab) {
+TEST_F(WidgetTestInteractive, DISABLED_GrabUngrab) {
   Widget* toplevel = CreateTopLevelPlatformWidget();
   Widget* child1 = CreateChildNativeWidgetWithParent(toplevel);
   Widget* child2 = CreateChildNativeWidgetWithParent(toplevel);
 
   toplevel->SetBounds(gfx::Rect(0, 0, 500, 500));
 
   child1->SetBounds(gfx::Rect(10, 10, 300, 300));
   View* view = new MouseView();
   view->SetBounds(0, 0, 300, 300);
   child1->GetRootView()->AddChildView(view);
@@ skipping 41 matching lines @@
   toplevel->OnMouseEvent(&released2);
   EXPECT_FALSE(toplevel->HasCapture());
   EXPECT_FALSE(child1->HasCapture());
   EXPECT_FALSE(child2->HasCapture());
 
   toplevel->CloseNow();
 }
 
 // Tests mouse move outside of the window into the "resize controller" and back
 // will still generate an OnMouseEntered and OnMouseExited event..
-TEST_F(WidgetTest, CheckResizeControllerEvents) {
+TEST_F(WidgetTestInteractive, CheckResizeControllerEvents) {
   Widget* toplevel = CreateTopLevelPlatformWidget();
 
   toplevel->SetBounds(gfx::Rect(0, 0, 100, 100));
 
   MouseView* view = new MouseView();
   view->SetBounds(90, 90, 10, 10);
   toplevel->GetRootView()->AddChildView(view);
 
   toplevel->Show();
   RunPendingMessages();
@@ skipping 55 matching lines @@
   bool active() const { return active_; }
 
  private:
   bool active_;
 
   DISALLOW_COPY_AND_ASSIGN(WidgetActivationTest);
 };
 
 // Tests whether the widget only becomes active when the underlying window
 // is really active.
-TEST_F(WidgetTest, WidgetNotActivatedOnFakeActivationMessages) {
+TEST_F(WidgetTestInteractive, WidgetNotActivatedOnFakeActivationMessages) {
   WidgetActivationTest widget1;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.native_widget = new DesktopNativeWidgetAura(&widget1);
   init_params.bounds = gfx::Rect(0, 0, 200, 200);
   widget1.Init(init_params);
   widget1.Show();
   EXPECT_EQ(true, widget1.active());
 
@@ skipping 31 matching lines @@
 
  private:
   ui::ModalType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ModalDialogDelegate);
 };
 
 // Tests whether the focused window is set correctly when a modal window is
 // created and destroyed. When it is destroyed it should focus the owner
 // window.
-TEST_F(WidgetTest, WindowModalWindowDestroyedActivationTest) {
+TEST_F(WidgetTestInteractive, WindowModalWindowDestroyedActivationTest) {
   // Create a top level widget.
   Widget top_level_widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 500, 500);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.native_widget = new DesktopNativeWidgetAura(&top_level_widget);
   top_level_widget.Init(init_params);
@@ skipping 16 matching lines @@
   EXPECT_EQ(dialog_window, aura::client::GetFocusClient(
                 top_level_window)->GetFocusedWindow());
 
   modal_dialog_widget->CloseNow();
   EXPECT_EQ(top_level_window, aura::client::GetFocusClient(
                 top_level_window)->GetFocusedWindow());
   top_level_widget.CloseNow();
 }
 
 // Test that when opening a system-modal window, capture is released.
-TEST_F(WidgetTest, SystemModalWindowReleasesCapture) {
+TEST_F(WidgetTestInteractive, SystemModalWindowReleasesCapture) {
   // Create a top level widget.
   Widget top_level_widget;
   Widget::InitParams init_params =
       CreateParams(Widget::InitParams::TYPE_WINDOW);
   init_params.show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect initial_bounds(0, 0, 500, 500);
   init_params.bounds = initial_bounds;
   init_params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   init_params.native_widget = new DesktopNativeWidgetAura(&top_level_widget);
   top_level_widget.Init(init_params);
@@ skipping 53 matching lines @@
 }  // namespace
 
 class WidgetCaptureTest : public ViewsTestBase {
  public:
   WidgetCaptureTest() {
   }
 
   virtual ~WidgetCaptureTest() {
   }
 
+  virtual void SetUp() OVERRIDE {
+    gfx::GLSurface::InitializeOneOffForTests();
+    base::FilePath pak_dir;
+    PathService::Get(base::DIR_MODULE, &pak_dir);
+    base::FilePath pak_file;
+    pak_file = pak_dir.Append(FILE_PATH_LITERAL("ui_test.pak"));
+    ui::ResourceBundle::InitSharedInstanceWithPakPath(pak_file);
+    ViewsTestBase::SetUp();
+  }
+
   // Verifies Widget::SetCapture() results in updating native capture along with
   // invoking the right Widget function.
   void TestCapture(bool use_desktop_native_widget) {
     CaptureLostTrackingWidget widget1;
     Widget::InitParams params1 =
         CreateParams(views::Widget::InitParams::TYPE_WINDOW);
     params1.native_widget = CreateNativeWidget(use_desktop_native_widget,
                                                &widget1);
     params1.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     widget1.Init(params1);
@@ skipping 126 matching lines @@
   ui::EventDispatchDetails details = widget1.GetNativeWindow()->
       GetHost()->dispatcher()->OnEventFromSource(&mouse_event);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(widget1.GetAndClearGotMouseEvent());
   EXPECT_FALSE(widget2.GetAndClearGotMouseEvent());
 }
 #endif
 
 }  // namespace test
 }  // namespace views