Add HandleInputEventAck message to allow out-of-process plugins to respond to user gestures.

ppapi/tests/test_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 <stdio.h>
 #include <string.h>
 #include <string>
 
@@ skipping 36 matching lines @@
 }
 
 }  // namespace
 
 TestFullscreen::TestFullscreen(TestingInstance* instance)
     : TestCase(instance),
       error_(),
       screen_mode_(instance),
       fullscreen_pending_(false),
       normal_pending_(false),
-      saw_first_fullscreen_didchangeview(false),
       set_fullscreen_true_callback_(instance->pp_instance()),
       fullscreen_callback_(instance->pp_instance()),
       normal_callback_(instance->pp_instance()) {
   screen_mode_.GetScreenSize(&screen_size_);
 }
 
 bool TestFullscreen::Init() {
   if (screen_size_.IsEmpty()) {
     instance_->AppendError("Failed to initialize screen_size_");
     return false;
@@ skipping 59 matching lines @@
     return ReportError("SetFullscreen(true) in fullscreen", true);
   if (!screen_mode_.IsFullscreen())
     return ReportError("IsFullscreen() in fullscreen^2", false);
 
   // 3. Switch to normal.
   // The transition is asynchronous and ends at DidChangeView().
   // No graphics devices can be bound while in transition.
   normal_pending_ = true;
   if (!screen_mode_.SetFullscreen(false))
     return ReportError("SetFullscreen(false) in fullscreen", false);
-  // Normal is now pending, so additional requests should fail.
-  if (screen_mode_.SetFullscreen(false))
-    return ReportError("SetFullscreen(false) in normal pending", true);
-  if (screen_mode_.SetFullscreen(true))
-    return ReportError("SetFullscreen(true) in normal pending", true);
-  if (!screen_mode_.IsFullscreen())
-    return ReportError("IsFullscreen() in normal transition", false);
-  // No graphics devices can be bound while in transition.
-  if (instance_->BindGraphics(graphics2d_))
-    return ReportError("BindGraphics() in normal transition", true);
   // DidChangeView() will call the callback once out of fullscreen mode.
   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", true);
@@ skipping 16 matching lines @@
       PP_INPUTEVENT_MOUSEBUTTON_LEFT,
       plugin_center,
       1,  // click_count
       mouse_movement);
 
   testing_interface_->SimulateInputEvent(instance_->pp_instance(),
                                          input_event.pp_resource());
 }
 
 void TestFullscreen::FailFullscreenTest(const std::string& error) {
-  screen_mode_.SetFullscreen(false);
-  fullscreen_pending_ = false;
   error_ = error;
   pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
 }
 
 void TestFullscreen::FailNormalTest(const std::string& error) {
-  normal_pending_ = false;
   error_ = error;
   pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
 }
 
 void TestFullscreen::PassFullscreenTest() {
-  fullscreen_pending_ = false;
   pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
 }
 
 void TestFullscreen::PassNormalTest() {
-  normal_pending_ = false;
   pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
 }
 
 // Transition to fullscreen can only happen when processing a user gesture.
 bool TestFullscreen::HandleInputEvent(const pp::InputEvent& event) {
   // We only let mouse events through and only mouse clicks count.
   if (event.GetType() != PP_INPUTEVENT_TYPE_MOUSEDOWN &&
       event.GetType() != PP_INPUTEVENT_TYPE_MOUSEUP)
     return false;
   // We got the gesture. No need to handle any more events.
   instance_->ClearInputEventRequest(PP_INPUTEVENT_CLASS_MOUSE);
   if (screen_mode_.IsFullscreen()) {
     FailFullscreenTest(
         ReportError("IsFullscreen() before fullscreen transition", true));
     return false;
   }
   fullscreen_pending_ = true;
   if (!screen_mode_.SetFullscreen(true)) {
     FailFullscreenTest(ReportError("SetFullscreen(true) in normal", false));
     return false;
   }
-  // Fullscreen is now pending, so additional requests should fail.
-  if (screen_mode_.SetFullscreen(true)) {
-    FailFullscreenTest(
-        ReportError("SetFullscreen(true) in fullscreen pending", true));
-    return false;
-  }
-  if (screen_mode_.SetFullscreen(false)) {
-    FailFullscreenTest(
-        ReportError("SetFullscreen(false) in fullscreen pending", true));
-  }
-  if (screen_mode_.IsFullscreen()) {
-    FailFullscreenTest(
-        ReportError("IsFullscreen() in fullscreen transition", true));
-    return false;
-  }
-  // No graphics devices can be bound while in transition.
-  if (instance_->BindGraphics(graphics2d_)) {
-    FailFullscreenTest(
-        ReportError("BindGraphics() in fullscreen transition", true));
-    return false;
-  }
   // DidChangeView() will complete the transition to fullscreen.
   return false;
 }
 
 bool TestFullscreen::PaintPlugin(pp::Size size, ColorPremul color) {
   PP_ImageDataFormat image_format = pp::ImageData::GetNativeImageDataFormat();
   uint32_t pixel_color = FormatColor(image_format, color);
   if (pixel_color == 0)
     return false;
   pp::Point origin(0, 0);
@@ skipping 22 matching lines @@
   for (int y = 0; y < size.height() && !error; y++) {
     for (int x = 0; x < size.width() && !error; x++) {
       uint32_t* readback_color = readback.GetAddr32(pp::Point(x, y));
       if (pixel_color != *readback_color)
         return false;
     }
   }
   return true;
 }
 
-// Transitions to/from fullscreen is asynchornous ending at DidChangeView.
-// When going to fullscreen, two DidChangeView calls are generated:
-// one for moving the plugin to the middle of window and one for stretching
-// the window and placing the plugin in the middle of the screen.
-// This is not something we advertise to users and not something they should
-// rely on. But the test checks for these, so we know when the underlying
-// implementation changes.
+// Transitions to/from fullscreen is asynchronous ending at DidChangeView.
+// The number of calls to DidChangeView during fullscreen / normal transitions
+// isn't specified by the API. The test waits until it the screen has
+// transitioned to the desired state.
 //
 // WebKit does not change the plugin size, but Pepper does explicitly set
 // it to screen width and height when SetFullscreen(true) is called and
 // resets it back when ViewChanged is received indicating that we exited
 // fullscreen.
 //
 // NOTE: The number of DidChangeView calls for <object> might be different.
 void TestFullscreen::DidChangeView(const pp::View& view) {
   pp::Rect position = view.GetRect();
   pp::Rect clip = view.GetClipRect();
 
   if (normal_position_.IsEmpty()) {
     normal_position_ = position;
     if (!PaintPlugin(position.size(), kSheerRed))
       error_ = "Failed to initialize plugin image";
   }
 
-  if (fullscreen_pending_ && !saw_first_fullscreen_didchangeview) {
-    saw_first_fullscreen_didchangeview = true;
-    if (screen_mode_.IsFullscreen())
-      FailFullscreenTest("DidChangeView1 is in fullscreen");
+  bool is_fullscreen = screen_mode_.IsFullscreen();
+  if (fullscreen_pending_ && is_fullscreen) {
+    fullscreen_pending_ = false;
+    if (!HasMidScreen(position, screen_size_))
+      FailFullscreenTest("DidChangeView is not in the middle of the screen");
     else if (position.size() != screen_size_)
-      FailFullscreenTest("DidChangeView1 does not have screen size");
-    // Wait for the 2nd DidChangeView.
-  } else if (fullscreen_pending_) {
-    saw_first_fullscreen_didchangeview = false;
-    if (!screen_mode_.IsFullscreen())
-      FailFullscreenTest("DidChangeView2 is not in fullscreen");
-    else if (!HasMidScreen(position, screen_size_))
-      FailFullscreenTest("DidChangeView2 is not in the middle of the screen");
-    else if (position.size() != screen_size_)
-      FailFullscreenTest("DidChangeView2 does not have screen size");
+      FailFullscreenTest("DidChangeView does not have 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 (!instance_->BindGraphics(graphics2d_))
       FailFullscreenTest("Failed to BindGraphics() in fullscreen");
     else if (!PaintPlugin(position.size(), kOpaqueYellow))
       FailFullscreenTest("Failed to paint plugin image in fullscreen");
     else
       PassFullscreenTest();
-  } else if (normal_pending_) {
+  } else if (normal_pending_ && !is_fullscreen) {
     normal_pending_ = false;
     if (screen_mode_.IsFullscreen())
       FailNormalTest("DidChangeview is in fullscreen");
     else if (position != normal_position_)
       FailNormalTest("DidChangeView position is not normal");
     else if (!instance_->BindGraphics(graphics2d_))
       FailNormalTest("Failed to BindGraphics() in normal");
     else if (!PaintPlugin(position.size(), kSheerBlue))
       FailNormalTest("Failed to paint plugin image in normal");
     else
       PassNormalTest();
   }
 }