1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "ppapi/tests/test_flash_fullscreen.h" 6 7 #include <stdio.h> 8 #include <string.h> 9 #include <string> 10 11 #include "ppapi/c/dev/ppb_testing_dev.h" 12 #include "ppapi/c/private/ppb_flash_fullscreen.h" 13 #include "ppapi/cpp/graphics_2d.h" 14 #include "ppapi/cpp/instance.h" 15 #include "ppapi/cpp/module.h" 16 #include "ppapi/cpp/point.h" 17 #include "ppapi/cpp/private/flash_fullscreen.h" 18 #include "ppapi/cpp/rect.h" 19 #include "ppapi/cpp/size.h" 20 #include "ppapi/tests/test_utils.h" 21 #include "ppapi/tests/testing_instance.h" 22 23 REGISTER_TEST_CASE(FlashFullscreen); 24 25 namespace { 26 27 bool IsFullscreenView(const pp::Rect& position, 28 const pp::Rect& clip, 29 const pp::Size& screen_size) { 30 return (position.point() == pp::Point(0, 0) && 31 position.size() == screen_size && 32 clip.point() == pp::Point(0, 0) && 33 clip.size() == screen_size); 34 } 35 36 } // namespace 37 38 TestFlashFullscreen::TestFlashFullscreen(TestingInstance* instance) 39 : TestCase(instance), 40 screen_mode_(instance), 41 fullscreen_pending_(false), 42 normal_pending_(false), 43 fullscreen_event_(instance->pp_instance()), 44 normal_event_(instance->pp_instance()) { 45 screen_mode_.GetScreenSize(&screen_size_); 46 } 47 48 bool TestFlashFullscreen::Init() { 49 return CheckTestingInterface(); 50 } 51 52 void TestFlashFullscreen::RunTests(const std::string& filter) { 53 RUN_TEST(GetScreenSize, filter); 54 RUN_TEST(NormalToFullscreenToNormal, filter); 55 } 56 57 std::string TestFlashFullscreen::TestGetScreenSize() { 58 if (screen_size_.width() < 320 || screen_size_.width() > 2560) 59 return ReportError("screen_size.width()", screen_size_.width()); 60 if (screen_size_.height() < 200 || screen_size_.height() > 2048) 61 return ReportError("screen_size.height()", screen_size_.height()); 62 PASS(); 63 } 64 65 std::string TestFlashFullscreen::TestNormalToFullscreenToNormal() { 66 // 0. Start in normal mode. 67 if (screen_mode_.IsFullscreen()) 68 return ReportError("IsFullscreen() at start", true); 69 70 // 1. Switch to fullscreen. 71 // The transition is asynchronous and ends at the next DidChangeView(). 72 // No graphics devices can be bound while in transition. 73 fullscreen_pending_ = true; 74 if (!screen_mode_.SetFullscreen(true)) 75 return ReportError("SetFullscreen(true) in normal", false); 76 pp::Graphics2D graphics2d_fullscreen(instance_, pp::Size(10, 10), false); 77 if (graphics2d_fullscreen.is_null()) 78 return "Failed to create graphics2d_fullscreen"; 79 // The out-of-process proxy is asynchronous, so testing for the following 80 // conditions is flaky and can only be done reliably in-process. 81 if (!testing_interface_->IsOutOfProcess()) { 82 if (instance_->BindGraphics(graphics2d_fullscreen)) 83 return ReportError("BindGraphics() in fullscreen transition", true); 84 if (screen_mode_.IsFullscreen()) 85 return ReportError("IsFullscreen() in fullscreen transtion", true); 86 } 87 88 // DidChangeView() will call the callback once in fullscreen mode. 89 fullscreen_event_.Wait(); 90 if (fullscreen_pending_) 91 return "fullscreen_pending_ has not been reset"; 92 if (!screen_mode_.IsFullscreen()) 93 return ReportError("IsFullscreen() in fullscreen", false); 94 if (!instance_->BindGraphics(graphics2d_fullscreen)) 95 return ReportError("BindGraphics() in fullscreen", false); 96 97 // 2. Stay in fullscreen. No change. 98 if (!screen_mode_.SetFullscreen(true)) 99 return ReportError("SetFullscreen(true) in fullscreen", false); 100 if (!screen_mode_.IsFullscreen()) 101 return ReportError("IsFullscreen() in fullscreen^2", false); 102 103 // 3. Switch to normal. 104 // The transition is synchronous in-process and asynchornous out-of-process 105 // because proxied IsFullscreen saves a roundtrip by relying on information 106 // communicated via a previous call to DidChangeView. 107 // Graphics devices can be bound right away. 108 normal_pending_ = true; 109 if (!screen_mode_.SetFullscreen(false)) 110 return ReportError("SetFullscreen(false) in fullscreen", false); 111 pp::Graphics2D graphics2d_normal(instance_, pp::Size(15, 15), false); 112 if (graphics2d_normal.is_null()) 113 return "Failed to create graphics2d_normal"; 114 if (!instance_->BindGraphics(graphics2d_normal)) 115 return ReportError("BindGraphics() in normal transition", false); 116 if (testing_interface_->IsOutOfProcess()) { 117 if (!screen_mode_.IsFullscreen()) 118 return ReportError("IsFullscreen() in normal transition", false); 119 normal_event_.Wait(); 120 if (normal_pending_) 121 return "normal_pending_ has not been reset"; 122 } 123 if (screen_mode_.IsFullscreen()) 124 return ReportError("IsFullscreen() in normal", true); 125 126 // 4. Stay in normal. No change. 127 if (!screen_mode_.SetFullscreen(false)) 128 return ReportError("SetFullscreen(false) in normal", false); 129 if (screen_mode_.IsFullscreen()) 130 return ReportError("IsFullscreen() in normal^2", true); 131 132 PASS(); 133 } 134 135 // Transition to fullscreen is asynchornous ending at DidChangeView. 136 // Transition to normal is synchronous in-process and asynchronous 137 // out-of-process ending at DidChangeView. 138 void TestFlashFullscreen::DidChangeView(const pp::View& view) { 139 pp::Rect position = view.GetRect(); 140 pp::Rect clip = view.GetClipRect(); 141 if (fullscreen_pending_ && IsFullscreenView(position, clip, screen_size_)) { 142 fullscreen_pending_ = false; 143 fullscreen_event_.Signal(); 144 } else if (normal_pending_ && 145 !IsFullscreenView(position, clip, screen_size_)) { 146 normal_pending_ = false; 147 if (testing_interface_->IsOutOfProcess()) 148 normal_event_.Signal(); 149 } 150 } 151
