blob: 2018702b352a64399b8fcb85c32aa34d481c1a30 [file] [log] [blame]
// 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 "ppapi/tests/test_flash_fullscreen.h"
#include <stdio.h>
#include <string.h>
#include <string>
#include "ppapi/c/private/ppb_flash_fullscreen.h"
#include "ppapi/cpp/graphics_2d.h"
#include "ppapi/cpp/input_event.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_event_(instance->pp_instance()),
normal_event_(instance->pp_instance()) {
screen_mode_.GetScreenSize(&screen_size_);
}
bool TestFlashFullscreen::Init() {
return CheckTestingInterface();
}
void TestFlashFullscreen::RunTests(const std::string& filter) {
RUN_TEST(GetScreenSize, filter);
RUN_TEST(NormalToFullscreenToNormal, filter);
}
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);
// 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);
// 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;
instance_->RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
SimulateUserGesture();
// DidChangeView() will call the callback once in fullscreen mode.
fullscreen_event_.Wait();
if (GotError())
return Error();
if (fullscreen_pending_)
return "fullscreen_pending_ has not been reset";
if (!screen_mode_.IsFullscreen())
return ReportError("IsFullscreen() in fullscreen", 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", 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_event_.Wait();
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::View& view) {
pp::Rect position = view.GetRect();
pp::Rect clip = view.GetClipRect();
if (normal_position_.IsEmpty())
normal_position_ = view.GetRect();
if (fullscreen_pending_ && IsFullscreenView(position, clip, screen_size_)) {
fullscreen_pending_ = false;
fullscreen_event_.Signal();
} else if (normal_pending_ &&
!IsFullscreenView(position, clip, screen_size_)) {
normal_pending_ = false;
if (testing_interface_->IsOutOfProcess())
normal_event_.Signal();
}
}
void TestFlashFullscreen::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 TestFlashFullscreen::GotError() {
return !error_.empty();
}
std::string TestFlashFullscreen::Error() {
std::string last_error = error_;
error_.clear();
return last_error;
}
void TestFlashFullscreen::FailFullscreenTest(const std::string& error) {
error_ = error;
fullscreen_event_.Signal();
}
bool TestFlashFullscreen::HandleInputEvent(const pp::InputEvent& event) {
if (event.GetType() != PP_INPUTEVENT_TYPE_MOUSEDOWN &&
event.GetType() != PP_INPUTEVENT_TYPE_MOUSEUP) {
return false;
}
instance_->ClearInputEventRequest(PP_INPUTEVENT_CLASS_MOUSE);
if (screen_mode_.IsFullscreen()) {
FailFullscreenTest(
ReportError("IsFullscreen() before fullscreen transition", true));
return false;
}
if (!screen_mode_.SetFullscreen(true)) {
FailFullscreenTest(
ReportError("SetFullscreen(true) in normal", false));
return false;
}
// DidChangeView() will complete the transition to fullscreen.
return false;
}