Add PPB_Fullscreen;0.5.

ppapi/tests/test_flash_fullscreen.cc

 // 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_fullscreen.h"
+#include "ppapi/tests/test_flash_fullscreen.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <string>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
-#include "ppapi/c/dev/ppb_fullscreen_dev.h"
-#include "ppapi/cpp/dev/fullscreen_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(Fullscreen);
+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
 
-TestFullscreen::TestFullscreen(TestingInstance* instance)
+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 TestFullscreen::Init() {
+bool TestFlashFullscreen::Init() {
   return InitTestingInterface();
 }
 
-void TestFullscreen::RunTest() {
+void TestFlashFullscreen::RunTest() {
   RUN_TEST(GetScreenSize);
   RUN_TEST(NormalToFullscreenToNormal);
 }
 
-std::string TestFullscreen::TestGetScreenSize() {
+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 TestFullscreen::TestNormalToFullscreenToNormal() {
+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);
@@ skipping 48 matching lines @@
     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 TestFullscreen::DidChangeView(const pp::Rect& position,
+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_);
   }
 }