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

1 files changed, 145 insertions, 0 deletions

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 <stdio.h>
+#include <string.h>
+#include <string>
+
+#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_);
+  }
+}