| // 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 "ppapi/tests/test_flash_fullscreen_for_browser_ui.h" |
| |
| #include <GLES2/gl2.h> |
| |
| #include "ppapi/c/ppb_opengles2.h" |
| #include "ppapi/cpp/input_event.h" |
| #include "ppapi/cpp/instance.h" |
| #include "ppapi/cpp/rect.h" |
| #include "ppapi/tests/testing_instance.h" |
| |
| REGISTER_TEST_CASE(FlashFullscreenForBrowserUI); |
| |
| TestFlashFullscreenForBrowserUI:: |
| TestFlashFullscreenForBrowserUI(TestingInstance* instance) |
| : TestCase(instance), |
| screen_mode_(instance), |
| view_change_event_(instance->pp_instance()), |
| callback_factory_(this) { |
| // This plugin should not be removed after this TestCase passes because |
| // browser UI testing requires it to remain and to be interactive. |
| instance_->set_remove_plugin(false); |
| } |
| |
| TestFlashFullscreenForBrowserUI::~TestFlashFullscreenForBrowserUI() { |
| } |
| |
| bool TestFlashFullscreenForBrowserUI::Init() { |
| opengl_es2_ = static_cast<const PPB_OpenGLES2*>( |
| pp::Module::Get()->GetBrowserInterface(PPB_OPENGLES2_INTERFACE)); |
| return opengl_es2_ && CheckTestingInterface(); |
| } |
| |
| void TestFlashFullscreenForBrowserUI::RunTests(const std::string& filter) { |
| RUN_TEST(EnterFullscreen, filter); |
| } |
| |
| std::string TestFlashFullscreenForBrowserUI::TestEnterFullscreen() { |
| if (screen_mode_.IsFullscreen()) |
| return ReportError("IsFullscreen() at start", true); |
| |
| // This is only allowed within a contet of a user gesture (e.g. mouse click). |
| if (screen_mode_.SetFullscreen(true)) |
| return ReportError("SetFullscreen(true) outside of user gesture", true); |
| |
| int32_t attribs[] = {PP_GRAPHICS3DATTRIB_RED_SIZE, 8, |
| PP_GRAPHICS3DATTRIB_GREEN_SIZE, 8, |
| PP_GRAPHICS3DATTRIB_BLUE_SIZE, 8, |
| PP_GRAPHICS3DATTRIB_ALPHA_SIZE, 8, |
| PP_GRAPHICS3DATTRIB_DEPTH_SIZE, 0, |
| PP_GRAPHICS3DATTRIB_STENCIL_SIZE, 0, |
| PP_GRAPHICS3DATTRIB_WIDTH, layer_size_.width(), |
| PP_GRAPHICS3DATTRIB_HEIGHT, layer_size_.height(), |
| PP_GRAPHICS3DATTRIB_NONE}; |
| graphics_3d_ = pp::Graphics3D(instance_, attribs); |
| instance_->BindGraphics(graphics_3d_); |
| |
| // Trigger another call to SetFullscreen(true) from HandleInputEvent(). |
| // The transition is asynchronous and ends at the next DidChangeView(). |
| view_change_event_.Reset(); |
| request_fullscreen_ = true; |
| instance_->RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE); |
| SimulateUserGesture(); |
| // DidChangeView() will call the callback once in fullscreen mode. |
| view_change_event_.Wait(); |
| if (GotError()) |
| return Error(); |
| |
| if (!screen_mode_.IsFullscreen()) |
| return ReportError("IsFullscreen() in fullscreen", false); |
| |
| const int32_t result = |
| instance_->RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_MOUSE | |
| PP_INPUTEVENT_CLASS_KEYBOARD); |
| if (result != PP_OK) |
| return ReportError("RequestFilteringInputEvents() failed", result); |
| |
| PASS(); |
| } |
| |
| void TestFlashFullscreenForBrowserUI::DidChangeView(const pp::View& view) { |
| layer_size_ = view.GetRect().size(); |
| if (normal_position_.IsEmpty()) |
| normal_position_ = view.GetRect(); |
| |
| if (!graphics_3d_.is_null()) { |
| graphics_3d_.ResizeBuffers(layer_size_.width(), layer_size_.height()); |
| RequestPaint(); |
| } |
| |
| view_change_event_.Signal(); |
| } |
| |
| void TestFlashFullscreenForBrowserUI::SimulateUserGesture() { |
| pp::Point plugin_center( |
| normal_position_.x() + normal_position_.width() / 2, |
| normal_position_.y() + normal_position_.height() / 2); |
| pp::Point mouse_movement; |
| pp::MouseInputEvent input_event( |
| instance_, |
| PP_INPUTEVENT_TYPE_MOUSEDOWN, |
| NowInTimeTicks(), // time_stamp |
| 0, // modifiers |
| PP_INPUTEVENT_MOUSEBUTTON_LEFT, |
| plugin_center, |
| 1, // click_count |
| mouse_movement); |
| |
| testing_interface_->SimulateInputEvent(instance_->pp_instance(), |
| input_event.pp_resource()); |
| } |
| |
| bool TestFlashFullscreenForBrowserUI::GotError() { |
| return !error_.empty(); |
| } |
| |
| std::string TestFlashFullscreenForBrowserUI::Error() { |
| std::string last_error = error_; |
| error_.clear(); |
| return last_error; |
| } |
| |
| void TestFlashFullscreenForBrowserUI::FailFullscreenTest( |
| const std::string& error) { |
| error_ = error; |
| view_change_event_.Signal(); |
| } |
| |
| bool TestFlashFullscreenForBrowserUI::HandleInputEvent( |
| const pp::InputEvent& event) { |
| if (event.GetType() != PP_INPUTEVENT_TYPE_MOUSEDOWN && |
| event.GetType() != PP_INPUTEVENT_TYPE_MOUSEUP && |
| event.GetType() != PP_INPUTEVENT_TYPE_CHAR) { |
| return false; |
| } |
| |
| if (request_fullscreen_) { |
| instance_->ClearInputEventRequest(PP_INPUTEVENT_CLASS_MOUSE); |
| if (screen_mode_.IsFullscreen()) { |
| FailFullscreenTest( |
| ReportError("IsFullscreen() before fullscreen transition", true)); |
| return false; |
| } |
| request_fullscreen_ = false; |
| if (!screen_mode_.SetFullscreen(true)) { |
| FailFullscreenTest( |
| ReportError("SetFullscreen(true) in normal", false)); |
| return false; |
| } |
| // DidChangeView() will complete the transition to fullscreen. |
| return false; |
| } |
| |
| ++num_trigger_events_; |
| RequestPaint(); |
| |
| return true; |
| } |
| |
| void TestFlashFullscreenForBrowserUI::RequestPaint() { |
| if (swap_pending_) |
| needs_paint_ = true; |
| else |
| DoPaint(); |
| } |
| |
| void TestFlashFullscreenForBrowserUI::DoPaint() { |
| if (num_trigger_events_ == 0) |
| opengl_es2_->ClearColor(graphics_3d_.pp_resource(), 0.0f, 1.0f, 0.0f, 1.0f); |
| else if (num_trigger_events_ % 2) |
| opengl_es2_->ClearColor(graphics_3d_.pp_resource(), 1.0f, 0.0f, 0.0f, 1.0f); |
| else |
| opengl_es2_->ClearColor(graphics_3d_.pp_resource(), 0.0f, 0.0f, 1.0f, 1.0f); |
| |
| opengl_es2_->Clear(graphics_3d_.pp_resource(), GL_COLOR_BUFFER_BIT); |
| swap_pending_ = true; |
| graphics_3d_.SwapBuffers( |
| callback_factory_.NewCallback(&TestFlashFullscreenForBrowserUI::DidSwap)); |
| } |
| |
| void TestFlashFullscreenForBrowserUI::DidSwap(int32_t last_compositor_result) { |
| swap_pending_ = false; |
| if (needs_paint_) { |
| needs_paint_ = false; |
| DoPaint(); |
| } |
| } |