From 06e0a34ae11c97e35ae67f6a006dc4a45cda58af Mon Sep 17 00:00:00 2001 From: "polina@google.com" Date: Tue, 27 Sep 2011 04:24:30 +0000 Subject: Add PPB_Fullscreen_Dev;0.5. Keep 0.4 for backwards compatiblity and point it to PPB_FlashFullscreen. The new implementation is based on http://codereview.chromium.org/7714017/ with some bug fixes. Update header comments. Main API differences between the old and the new implementation: - transition from fullscreen is now asynchronous and ends at DidChangeView just like transition to fullscreen; graphics devices cannot be bound during the transition. - when switching to/from fullscreen 3D resources no longer need to be re-created. - transitions to fullscreen are only possible when processing user user gestures. - transition to fullscreen results in 2 DidChangeViews, one for moving the plugin to the middle of the window and one for stretching the window and placing the plugin in the middle of the screen. - the size of the plugin is not changed when going to/from fullscreen. Testing: - Mapped ppapi_tests:test_fullscreen to ppapi_tests:test_flash_fullscreen. - Updated test_fullscreen to work with the new implementation. To be testable automatically this needs enhancements to the testing infrastructure for generating user gestures. For now marked the test as DISABLED. - Disabled NaCl's ppapi_ppb_fullscreen_browser_test for the same reasons as above. - To re-enable both tests, we will first need to add user gesture capabilites to PPB_Testing. - Build 0.4 ppapi_test:test_fullscreen and ran this out of process and in process with the newly build revision of chrome to verify backwards compatability. - In a separate CL, will update NaCl's ppapi_ppb_fullscreen_browser_test to work with the new implementation, for now only manually. BUG=41780 TEST=see above Review URL: http://codereview.chromium.org/7826017 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@102888 0039d316-1c4b-4281-b951-d872f2087c98 --- ppapi/tests/test_flash_fullscreen.cc | 145 +++++++++++++++++++++++++++++++++++ 1 file changed, 145 insertions(+) create mode 100644 ppapi/tests/test_flash_fullscreen.cc (limited to 'ppapi/tests/test_flash_fullscreen.cc') diff --git a/ppapi/tests/test_flash_fullscreen.cc b/ppapi/tests/test_flash_fullscreen.cc new file mode 100644 index 0000000..09e0b18 --- /dev/null +++ b/ppapi/tests/test_flash_fullscreen.cc @@ -0,0 +1,145 @@ +// Copyright (c) 2011 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.h" + +#include +#include +#include + +#include "ppapi/c/dev/ppb_testing_dev.h" +#include "ppapi/c/private/ppb_flash_fullscreen.h" +#include "ppapi/cpp/graphics_2d.h" +#include "ppapi/cpp/instance.h" +#include "ppapi/cpp/module.h" +#include "ppapi/cpp/point.h" +#include "ppapi/cpp/private/flash_fullscreen.h" +#include "ppapi/cpp/rect.h" +#include "ppapi/cpp/size.h" +#include "ppapi/tests/test_utils.h" +#include "ppapi/tests/testing_instance.h" + +REGISTER_TEST_CASE(FlashFullscreen); + +namespace { + +bool IsFullscreenView(const pp::Rect& position, + const pp::Rect& clip, + const pp::Size& screen_size) { + return (position.point() == pp::Point(0, 0) && + position.size() == screen_size && + clip.point() == pp::Point(0, 0) && + clip.size() == screen_size); +} + +} // namespace + +TestFlashFullscreen::TestFlashFullscreen(TestingInstance* instance) + : TestCase(instance), + screen_mode_(instance), + fullscreen_pending_(false), + normal_pending_(false), + fullscreen_callback_(instance->pp_instance()), + normal_callback_(instance->pp_instance()) { + screen_mode_.GetScreenSize(&screen_size_); +} + +bool TestFlashFullscreen::Init() { + return InitTestingInterface(); +} + +void TestFlashFullscreen::RunTest() { + RUN_TEST(GetScreenSize); + RUN_TEST(NormalToFullscreenToNormal); +} + +std::string TestFlashFullscreen::TestGetScreenSize() { + if (screen_size_.width() < 320 || screen_size_.width() > 2560) + return ReportError("screen_size.width()", screen_size_.width()); + if (screen_size_.height() < 200 || screen_size_.height() > 2048) + return ReportError("screen_size.height()", screen_size_.height()); + PASS(); +} + +std::string TestFlashFullscreen::TestNormalToFullscreenToNormal() { + // 0. Start in normal mode. + if (screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() at start", true); + + // 1. Switch to fullscreen. + // The transition is asynchronous and ends at the next DidChangeView(). + // No graphics devices can be bound while in transition. + fullscreen_pending_ = true; + if (!screen_mode_.SetFullscreen(true)) + return ReportError("SetFullscreen(true) in normal", false); + pp::Graphics2D graphics2d_fullscreen(instance_, pp::Size(10, 10), false); + if (graphics2d_fullscreen.is_null()) + return "Failed to create graphics2d_fullscreen"; + if (instance_->BindGraphics(graphics2d_fullscreen)) + return ReportError("BindGraphics() in fullscreen transition", true); + if (screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() in fullscreen transtion", true); + + // DidChangeView() will call the callback once in fullscreen mode. + fullscreen_callback_.WaitForResult(); + if (fullscreen_pending_) + return "fullscreen_pending_ has not been reset"; + if (!screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() in fullscreen", false); + if (!instance_->BindGraphics(graphics2d_fullscreen)) + return ReportError("BindGraphics() in fullscreen", false); + + // 2. Stay in fullscreen. No change. + if (!screen_mode_.SetFullscreen(true)) + return ReportError("SetFullscreen(true) in fullscreen", false); + if (!screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() in fullscreen^2", false); + + // 3. Switch to normal. + // The transition is synchronous in-process and asynchornous out-of-process + // because proxied IsFullscreen saves a roundtrip by relying on information + // communicated via a previous call to DidChangeView. + // Graphics devices can be bound right away. + normal_pending_ = true; + if (!screen_mode_.SetFullscreen(false)) + return ReportError("SetFullscreen(false) in fullscreen", false); + pp::Graphics2D graphics2d_normal(instance_, pp::Size(15, 15), false); + if (graphics2d_normal.is_null()) + return "Failed to create graphics2d_normal"; + if (!instance_->BindGraphics(graphics2d_normal)) + return ReportError("BindGraphics() in normal transition", false); + if (testing_interface_->IsOutOfProcess()) { + if (!screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() in normal transition", false); + normal_callback_.WaitForResult(); + if (normal_pending_) + return "normal_pending_ has not been reset"; + } + if (screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() in normal", true); + + // 4. Stay in normal. No change. + if (!screen_mode_.SetFullscreen(false)) + return ReportError("SetFullscreen(false) in normal", false); + if (screen_mode_.IsFullscreen()) + return ReportError("IsFullscreen() in normal^2", true); + + PASS(); +} + +// Transition to fullscreen is asynchornous ending at DidChangeView. +// Transition to normal is synchronous in-process and asynchronous +// out-of-process ending at DidChangeView. +void TestFlashFullscreen::DidChangeView(const pp::Rect& position, + const pp::Rect& clip) { + if (fullscreen_pending_ && IsFullscreenView(position, clip, screen_size_)) { + fullscreen_pending_ = false; + pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_); + } else if (normal_pending_ && + !IsFullscreenView(position, clip, screen_size_)) { + normal_pending_ = false; + if (testing_interface_->IsOutOfProcess()) + pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_); + } +} -- cgit v1.1