tests: Use runPendingTasks instead of WebThread::enterRunLoop()/exitRunLoop()

Source/web/tests/AssociatedURLLoaderTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/testing/URLTestHelpers.h"
+#include "core/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoader.h"
 #include "public/platform/WebURLLoaderClient.h"
 #include "public/platform/WebURLRequest.h"
 #include "public/platform/WebURLResponse.h"
 #include "public/platform/WebUnitTestSupport.h"
 #include "public/web/WebFrame.h"
 #include "public/web/WebURLLoaderOptions.h"
 #include "public/web/WebView.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 #include <gtest/gtest.h>
 
 using namespace blink;
 using blink::URLTestHelpers::toKURL;
+using blink::testing::runPendingTasks;
 
 namespace {
 
-class AssociatedURLLoaderTest : public testing::Test,
+class AssociatedURLLoaderTest : public ::testing::Test,
                                 public WebURLLoaderClient {
 public:
     AssociatedURLLoaderTest()
         :  m_willSendRequest(false)
         ,  m_didSendData(false)
         ,  m_didReceiveResponse(false)
         ,  m_didReceiveData(false)
         ,  m_didReceiveCachedMetadata(false)
         ,  m_didFinishLoading(false)
         ,  m_didFail(false)
-        ,  m_runningMessageLoop(false)
     {
         // Reuse one of the test files from WebFrameTest.
         m_baseFilePath = Platform::current()->unitTestSupport()->webKitRootDir();
         m_baseFilePath.append("/Source/web/tests/data/");
         m_frameFilePath = m_baseFilePath;
         m_frameFilePath.append("iframes_test.html");
     }
 
     KURL RegisterMockedUrl(const std::string& urlRoot, const WTF::String& filename)
     {
@@ skipping 93 matching lines @@
     void didFinishLoading(WebURLLoader* loader, double finishTime, int64_t encodedDataLength)
     {
         m_didFinishLoading = true;
         EXPECT_EQ(m_expectedLoader, loader);
     }
 
     void didFail(WebURLLoader* loader, const WebURLError& error)
     {
         m_didFail = true;
         EXPECT_EQ(m_expectedLoader, loader);
-        if (m_runningMessageLoop) {
-            m_runningMessageLoop = false;
-            Platform::current()->currentThread()->exitRunLoop();
-        }
     }
 
     void CheckMethodFails(const char* unsafeMethod)
     {
         WebURLRequest request;
         request.initialize();
         request.setURL(toKURL("http://www.test.com/success.html"));
         request.setHTTPMethod(WebString::fromUTF8(unsafeMethod));
         WebURLLoaderOptions options;
         options.untrustedHTTP = true;
@@ skipping 21 matching lines @@
 
     void CheckFails(const WebURLRequest& request, WebURLLoaderOptions options = WebURLLoaderOptions())
     {
         m_expectedLoader = createAssociatedURLLoader(options);
         EXPECT_TRUE(m_expectedLoader);
         m_didFail = false;
         m_expectedLoader->loadAsynchronously(request, this);
         // Failure should not be reported synchronously.
         EXPECT_FALSE(m_didFail);
         // Allow the loader to return the error.
-        m_runningMessageLoop = true;
-        Platform::current()->currentThread()->enterRunLoop();
+        runPendingTasks();
         EXPECT_TRUE(m_didFail);
         EXPECT_FALSE(m_didReceiveResponse);
     }
 
     bool CheckAccessControlHeaders(const char* headerName, bool exposed)
     {
         std::string id("http://www.other.com/CheckAccessControlExposeHeaders_");
         id.append(headerName);
         if (exposed)
             id.append("-Exposed");
@@ skipping 41 matching lines @@
     WebURLRequest m_expectedNewRequest;
     WebURLResponse m_expectedRedirectResponse;
     bool m_willSendRequest;
     bool m_didSendData;
     bool m_didReceiveResponse;
     bool m_didDownloadData;
     bool m_didReceiveData;
     bool m_didReceiveCachedMetadata;
     bool m_didFinishLoading;
     bool m_didFail;
-    bool m_runningMessageLoop;
 };
 
 // Test a successful same-origin URL load.
 TEST_F(AssociatedURLLoaderTest, SameOriginSuccess)
 {
     KURL url = toKURL("http://www.test.com/SameOriginSuccess.html");
     WebURLRequest request;
     request.initialize();
     request.setURL(url);
 
@@ skipping 408 matching lines @@
     m_expectedLoader->loadAsynchronously(request, this);
     serveRequests();
     EXPECT_TRUE(m_didReceiveResponse);
     EXPECT_TRUE(m_didReceiveData);
     EXPECT_TRUE(m_didFinishLoading);
 
     EXPECT_FALSE(m_actualResponse.httpHeaderField(headerNameString).isEmpty());
 }
 
 }