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

ppapi/tests/test_flash_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_flash_fullscreen.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <string>
 
@@ skipping 22 matching lines @@
           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()) {
+      fullscreen_event_(instance->pp_instance()),
+      normal_event_(instance->pp_instance()) {
   screen_mode_.GetScreenSize(&screen_size_);
 }
 
 bool TestFlashFullscreen::Init() {
   return CheckTestingInterface();
 }
 
 void TestFlashFullscreen::RunTests(const std::string& filter) {
   RUN_TEST(GetScreenSize, filter);
   RUN_TEST(NormalToFullscreenToNormal, filter);
@@ skipping 24 matching lines @@
   // The out-of-process proxy is asynchronous, so testing for the following
   // conditions is flaky and can only be done reliably in-process.
   if (!testing_interface_->IsOutOfProcess()) {
     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();
+  fullscreen_event_.Wait();
   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();
+    normal_event_.Wait();
     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::View& view) {
   pp::Rect position = view.GetRect();
   pp::Rect clip = view.GetClipRect();
   if (fullscreen_pending_ && IsFullscreenView(position, clip, screen_size_)) {
     fullscreen_pending_ = false;
-    pp::Module::Get()->core()->CallOnMainThread(0, fullscreen_callback_);
+    fullscreen_event_.Signal();
   } else if (normal_pending_ &&
              !IsFullscreenView(position, clip, screen_size_)) {
     normal_pending_ = false;
     if (testing_interface_->IsOutOfProcess())
-      pp::Module::Get()->core()->CallOnMainThread(0, normal_callback_);
+      normal_event_.Signal();
   }
 }