PPAPI Fullscreen: move out of Dev.

ppapi/native_client/tests/ppapi_browser/ppb_fullscreen/ppapi_ppb_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.
 
-// Tests PPB_Fullscreen_Dev.
+// Tests PPB_Fullscreen.
 
 #include <string.h>
 
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/tests/ppapi_test_lib/get_browser_interface.h"
 #include "native_client/tests/ppapi_test_lib/test_interface.h"
 #include "native_client/tests/ppapi_test_lib/testable_callback.h"
 
-#include "ppapi/c/dev/ppb_fullscreen_dev.h"
 #include "ppapi/c/ppb_core.h"
+#include "ppapi/c/ppb_fullscreen.h"
 #include "ppapi/c/ppb_graphics_2d.h"
 #include "ppapi/c/ppb_input_event.h"
 #include "ppapi/c/ppb_instance.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_size.h"
 
 namespace {
@@ skipping 33 matching lines @@
   PP_Bool not_always_opaque = PP_FALSE;
   *graphics2d =
       PPBGraphics2D()->Create(pp_instance(), &size, not_always_opaque);
   return (*graphics2d != kInvalidResource);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Test cases
 ////////////////////////////////////////////////////////////////////////////////
 
-// Test for the availability of PPB_FULLSCREEN_DEV_INTERFACE.
-void TestGetInterface() {
-  printf("--- TestGetInterface\n");
-  EXPECT(PPBFullscreenDev() != NULL);
-  TEST_PASSED;
-}
-
 // Test
 //   PP_Bool (*IsFullscreen)(PP_Instance instance);
 void TestIsFullscreenTrue() {
   printf("--- TestIsFullscreenTrue\n");
-  EXPECT(PPBFullscreenDev()->IsFullscreen(pp_instance()) == PP_TRUE);
+  EXPECT(PPBFullscreen()->IsFullscreen(pp_instance()) == PP_TRUE);
   TEST_PASSED;
 }
 
 void TestIsFullscreenFalse() {
   printf("--- TestIsFullscreenFalse\n");
-  EXPECT(PPBFullscreenDev()->IsFullscreen(pp_instance()) == PP_FALSE);
+  EXPECT(PPBFullscreen()->IsFullscreen(pp_instance()) == PP_FALSE);
   TEST_PASSED;
 }
 
 // Test
 //   PP_Bool (*SetFullscreen)(PP_Instance instance, PP_Bool fullscreen);
 bool g_fullscreen_pending = false;
 bool g_normal_pending = false;
 
 void TestSetFullscreenTrue() {
   printf("--- TestSetFullscreenTrue\n");
-  const PPB_Fullscreen_Dev* ppb = PPBFullscreenDev();
+  const PPB_Fullscreen* ppb = PPBFullscreen();
   if (ppb->IsFullscreen(pp_instance()) == PP_FALSE) {
     // Transition to fullscreen.
     // This can only be done when processing a user gesture -
     // see HandleInputEvent().
     EXPECT(ppb->SetFullscreen(pp_instance(), PP_TRUE) == PP_FALSE);
     EXPECT(PPBInputEvent()->
            RequestInputEvents(pp_instance(),
                               PP_INPUTEVENT_CLASS_MOUSE) == PP_OK);
   } else {
     // No change.
     EXPECT(ppb->SetFullscreen(pp_instance(), PP_TRUE) == PP_FALSE);
     EXPECT(ppb->IsFullscreen(pp_instance()) == PP_TRUE);
     TEST_PASSED;
   }
 }
 
 void TestSetFullscreenFalse() {
   printf("--- TestSetFullscreenFalse\n");
-  const PPB_Fullscreen_Dev* ppb = PPBFullscreenDev();
+  const PPB_Fullscreen* ppb = PPBFullscreen();
   if (ppb->IsFullscreen(pp_instance()) == PP_TRUE) {
     // Transition out of fullscreen.
     EXPECT(CreateGraphics2D(&g_graphics2d));
     // The transition is asynchronous and ends at the next DidChangeView().
     EXPECT(ppb->SetFullscreen(pp_instance(), PP_FALSE) == PP_TRUE);
     g_normal_pending = true;
     // Transition is pending, so additional requests fail.
     EXPECT(ppb->SetFullscreen(pp_instance(), PP_FALSE) == PP_FALSE);
     EXPECT(ppb->SetFullscreen(pp_instance(), PP_TRUE) == PP_FALSE);
     EXPECT(ppb->IsFullscreen(pp_instance()) == PP_TRUE);
     // No 2D or 3D device can be bound during transition.
     EXPECT(PPBGraphics2D()->IsGraphics2D(g_graphics2d) == PP_TRUE);
     EXPECT(PPBInstance()->BindGraphics(pp_instance(), g_graphics2d) ==
            PP_FALSE);
     // The transition ends at the next DidChangeView().
   } else {
     // No change.
     EXPECT(ppb->SetFullscreen(pp_instance(), PP_FALSE) == PP_FALSE);
     EXPECT(ppb->IsFullscreen(pp_instance()) == PP_FALSE);
     TEST_PASSED;
   }
 }
 
 // Test
 //   PP_Bool (*GetScreenSize)(PP_Instance instance, struct PP_Size* size);
 
 void TestGetScreenSizeHelper(PP_Size min_size, PP_Size max_size) {
   PP_Size size = PP_MakeSize(0, 0);
-  EXPECT(PPBFullscreenDev()->GetScreenSize(pp_instance(), &size) == PP_TRUE);
+  EXPECT(PPBFullscreen()->GetScreenSize(pp_instance(), &size) == PP_TRUE);
   EXPECT(IsSizeInRange(size, min_size, max_size));
 }
 
 void TestGetScreenSize() {
   printf("--- TestGetScreenSize\n");
   TestGetScreenSizeHelper(kSize320x200, kSize2560x2048);
   TEST_PASSED;
 }
 
 void TestGetScreenSize2560x1600() {
@@ skipping 16 matching lines @@
 // gesture (e.g. mouse click).
 PP_Bool HandleInputEvent(PP_Instance instance, PP_Resource event) {
   PP_InputEvent_Type event_type = PPBInputEvent()->GetType(event);
   if (event_type != PP_INPUTEVENT_TYPE_MOUSEDOWN &&
       event_type != PP_INPUTEVENT_TYPE_MOUSEUP)
     return PP_FALSE;  // Not a mouse click.
   printf("--- PPP_InputEvent::HandleInputEvent\n");
   // We got the user gesture we needed, no need to handle events anymore.
   PPBInputEvent()->ClearInputEventRequest(pp_instance(),
                                           PP_INPUTEVENT_CLASS_MOUSE);
-  EXPECT(PPBFullscreenDev()->IsFullscreen(pp_instance()) == PP_FALSE);
+  EXPECT(PPBFullscreen()->IsFullscreen(pp_instance()) == PP_FALSE);
   EXPECT(CreateGraphics2D(&g_graphics2d));
-  EXPECT(PPBFullscreenDev()->SetFullscreen(pp_instance(), PP_TRUE) == PP_TRUE);
+  EXPECT(PPBFullscreen()->SetFullscreen(pp_instance(), PP_TRUE) == PP_TRUE);
   g_fullscreen_pending = true;
   // Transition is pending, so additional requests fail.
-  EXPECT(PPBFullscreenDev()->SetFullscreen(pp_instance(), PP_TRUE) == PP_FALSE);
-  EXPECT(PPBFullscreenDev()->SetFullscreen(pp_instance(), PP_FALSE) ==
+  EXPECT(PPBFullscreen()->SetFullscreen(pp_instance(), PP_TRUE) == PP_FALSE);
+  EXPECT(PPBFullscreen()->SetFullscreen(pp_instance(), PP_FALSE) ==
          PP_FALSE);
-  EXPECT(PPBFullscreenDev()->IsFullscreen(pp_instance()) == PP_FALSE);
+  EXPECT(PPBFullscreen()->IsFullscreen(pp_instance()) == PP_FALSE);
   // No 2D or 3D device can be bound during transition.
   EXPECT(PPBGraphics2D()->IsGraphics2D(g_graphics2d) == PP_TRUE);
   EXPECT(PPBInstance()->BindGraphics(pp_instance(), g_graphics2d) ==
          PP_FALSE);
   // The transition ends at the next DidChangeView().
   return PP_FALSE;
 }
 
 const PPP_InputEvent ppp_input_event_interface = {
     &HandleInputEvent
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // PPP_Instance
 ////////////////////////////////////////////////////////////////////////////////
 
 PP_Size GetScreenSize() {
   PP_Size screen_size = PP_MakeSize(0, 0);
-  CHECK(PPBFullscreenDev()->GetScreenSize(pp_instance(), &screen_size));
+  CHECK(PPBFullscreen()->GetScreenSize(pp_instance(), &screen_size));
   return screen_size;
 }
 
 bool HasMidScreen(const PP_Rect* position) {
   static PP_Size screen_size = GetScreenSize();
   static int32_t mid_x = screen_size.width / 2;
   static int32_t mid_y = screen_size.height / 2;
   PP_Point origin = position->point;
   PP_Size size = position->size;
   return (origin.x < mid_x && mid_x < origin.x + size.width &&
@@ skipping 18 matching lines @@
   // Remember the original position on the first DidChangeView.
   if (g_normal_position.size.width == 0 && g_normal_position.size.height == 0) {
     g_normal_position = PP_MakeRectFromXYWH(position->point.x,
                                             position->point.y,
                                             position->size.width,
                                             position->size.height);
   }
 
   const char* test = NULL;
   PP_Size screen_size = GetScreenSize();
-  if (g_fullscreen_pending && PPBFullscreenDev()->IsFullscreen(pp_instance())) {
+  if (g_fullscreen_pending && PPBFullscreen()->IsFullscreen(pp_instance())) {
     test = "TestSetFullscreenTrue";
     g_fullscreen_pending = false;
     EXPECT(IsSizeEqual(position->size, screen_size));
     // NOTE: we cannot reliably test for clip size being equal to the screen
     // because it might be affected by JS console, info bars, etc.
   } else if (g_normal_pending &&
-             !PPBFullscreenDev()->IsFullscreen(pp_instance())) {
+             !PPBFullscreen()->IsFullscreen(pp_instance())) {
     test = "TestSetFullscreenFalse";
     g_normal_pending = false;
     EXPECT(IsRectEqual(*position, g_normal_position));
   }
   if (test != NULL) {
     // We should now be able to bind 2D and 3D devices.
     EXPECT(PPBGraphics2D()->IsGraphics2D(g_graphics2d) == PP_TRUE);
     EXPECT(PPBInstance()->BindGraphics(pp_instance(), g_graphics2d) == PP_TRUE);
     PPBCore()->ReleaseResource(g_graphics2d);
     PostTestMessage(test, "PASSED");
   }
 }
 
 const PPP_Instance ppp_instance_interface = {
   DidCreateDefault,
   DidDestroyDefault,
   DidChangeView,
   DidChangeFocusDefault,
   HandleDocumentLoadDefault
 };
 
 }  // namespace
 
 void SetupTests() {
-  RegisterTest("TestGetInterface", TestGetInterface);
   RegisterTest("TestIsFullscreenTrue", TestIsFullscreenTrue);
   RegisterTest("TestIsFullscreenFalse", TestIsFullscreenFalse);
   RegisterTest("TestSetFullscreenTrue", TestSetFullscreenTrue);
   RegisterTest("TestSetFullscreenFalse", TestSetFullscreenFalse);
   RegisterTest("TestGetScreenSize", TestGetScreenSize);
   RegisterTest("TestGetScreenSize2560x1600", TestGetScreenSize2560x1600);
   RegisterTest("TestGetScreenSize1920x1200", TestGetScreenSize1920x1200);
 }
 
 void SetupPluginInterfaces() {
   RegisterPluginInterface(PPP_INSTANCE_INTERFACE, &ppp_instance_interface);
   RegisterPluginInterface(PPP_INPUT_EVENT_INTERFACE,
                           &ppp_input_event_interface);
 }