PPAPI: Refactor ppapi test callbacks to ease testing blocking callbacks.

ppapi/tests/test_fullscreen.cc

 // Copyright (c) 2012 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 38 matching lines @@
 
 }  // namespace
 
 TestFullscreen::TestFullscreen(TestingInstance* instance)
     : TestCase(instance),
       error_(),
       screen_mode_(instance),
       painted_color_(0),
       fullscreen_pending_(false),
       normal_pending_(false),
-      set_fullscreen_true_callback_(instance->pp_instance()),
-      fullscreen_callback_(instance->pp_instance()),
-      normal_callback_(instance->pp_instance()) {
+      fullscreen_event_(instance->pp_instance()),
+      normal_event_(instance->pp_instance()) {
   screen_mode_.GetScreenSize(&screen_size_);
 }
 
 bool TestFullscreen::Init() {
   if (screen_size_.IsEmpty()) {
     instance_->AppendError("Failed to initialize screen_size_");
     return false;
   }
   graphics2d_ = pp::Graphics2D(instance_, screen_size_, true);
   if (!instance_->BindGraphics(graphics2d_)) {
@@ skipping 36 matching lines @@
 
   // 1. Switch to fullscreen.
   // This is only allowed within a context of a user gesture (e.g. mouse click).
   if (screen_mode_.SetFullscreen(true))
     return ReportError("SetFullscreen(true) outside of user gesture", true);
   // Trigger another call to SetFullscreen(true) from HandleInputEvent().
   // The transition is asynchronous and ends at the next DidChangeView().
   instance_->RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
   SimulateUserGesture();
   // DidChangeView() will call the callback once in fullscreen mode.
-  fullscreen_callback_.WaitForResult();
+  fullscreen_event_.Wait();
   if (GotError())
     return Error();
   if (fullscreen_pending_)
     return "fullscreen_pending_ has not been reset";
   if (!screen_mode_.IsFullscreen())
     return ReportError("IsFullscreen() in fullscreen", false);
 
   // 2. Stay in fullscreen. No change.
   if (screen_mode_.SetFullscreen(true))
     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);
-  // DidChangeView() will call the callback once out of fullscreen mode.
-  normal_callback_.WaitForResult();
+  // DidChangeView() will signal once out of fullscreen mode.
+  normal_event_.Wait();
   if (GotError())
     return Error();
   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 17 matching lines @@
       plugin_center,
       1,  // click_count
       mouse_movement);
 
   testing_interface_->SimulateInputEvent(instance_->pp_instance(),
                                          input_event.pp_resource());
 }
 
 void TestFullscreen::FailFullscreenTest(const std::string& error) {
   error_ = error;
-  pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
+  fullscreen_event_.Signal();
 }
 
 void TestFullscreen::FailNormalTest(const std::string& error) {
   error_ = error;
-  pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
+  normal_event_.Signal();
 }
 
 void TestFullscreen::PassFullscreenTest() {
-  pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
+  fullscreen_event_.Signal();
 }
 
 void TestFullscreen::PassNormalTest() {
-  pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
+  normal_event_.Signal();
 }
 
 // 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);
@@ skipping 96 matching lines @@
   } else if (normal_pending_ && !is_fullscreen) {
     normal_pending_ = false;
     if (screen_mode_.IsFullscreen())
       FailNormalTest("DidChangeview is in fullscreen");
     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");
   }
 }