Port a resource fetcher test shell test to linux.

webkit/glue/resource_fetcher_unittest.cc

 // Copyright (c) 2006-2008 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 "config.h"
 
 #include "base/compiler_specific.h"
 
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "ResourceResponse.h"
 MSVC_POP_WARNING();
 #undef LOG
 
+#if defined(OS_LINUX)
+#include <gtk/gtk.h>
+#endif
+
 #include "webkit/glue/unittest_test_server.h"
 #include "webkit/glue/webview.h"
 #include "webkit/glue/webframe_impl.h"
 #include "webkit/glue/resource_fetcher.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 #include "webkit/tools/test_shell/test_shell_test.h"
 
 using WebCore::ResourceResponse;
 
 namespace {
 
-
 class ResourceFetcherTests : public TestShellTest {
  public:
   void SetUp() {
     TestShellTest::SetUp();
   }
   void TearDown() {
     TestShellTest::TearDown();
   }
 };
 
 static const int kMaxWaitTimeMs = 5000;
 static const int kWaitIntervalMs = 100;
 
 class FetcherDelegate : public ResourceFetcher::Delegate {
  public:
   FetcherDelegate()
       : timer_id_(0), completed_(false), time_elapsed_ms_(0) {
     // Start a repeating timer waiting for the download to complete.  The
     // callback has to be a static function, so we hold on to our instance.
     FetcherDelegate::instance_ = this;
-    timer_id_ = SetTimer(NULL, NULL, kWaitIntervalMs,
-                         &FetcherDelegate::TimerCallback);
+    CreateTimer(kWaitIntervalMs);
   }
-  
+
   virtual void OnURLFetchComplete(const ResourceResponse& response,
                                   const std::string& data) {
     response_ = response;
     data_ = data;
     completed_ = true;
-    KillTimer(NULL, timer_id_);
+    DestroyTimer();
     MessageLoop::current()->Quit();
   }
 
   bool completed() const { return completed_; }
   bool timed_out() const { return time_elapsed_ms_ > kMaxWaitTimeMs; }
 
   int time_elapsed_ms() const { return time_elapsed_ms_; }
   std::string data() const { return data_; }
   ResourceResponse response() const { return response_; }
 
   // Wait for the request to complete or timeout.  We use a loop here b/c the
   // testing infrastructure (test_shell) can generate spurious calls to the
   // MessageLoop's Quit method.
   void WaitForResponse() {
     while (!completed() && !timed_out())
       MessageLoop::current()->Run();
   }
 
+  void CreateTimer(int interval) {
+#if defined(OS_WIN)
+    timer_id_ = ::SetTimer(NULL, NULL, interval,
+                           &FetcherDelegate::TimerCallback);
+#elif defined(OS_LINUX)
+    timer_id_ = g_timeout_add(interval, &FetcherDelegate::TimerCallback, NULL);
+#endif
+  }
+
+  void DestroyTimer() {
+#if defined(OS_WIN)
+    ::KillTimer(NULL, timer_id_);
+#elif defined(OS_LINUX)
+    g_source_remove(timer_id_);
+#endif
+  }
+
+#if defined(OS_WIN)
   // Static timer callback, just passes through to instance version.
   static VOID CALLBACK TimerCallback(HWND hwnd, UINT msg, UINT_PTR timer_id,
                                      DWORD ms) {
-    instance_->TimerFired(hwnd, timer_id);
+    instance_->TimerFired();
   }
-  
-  void TimerFired(HWND hwnd, UINT_PTR timer_id) {
+#elif defined(OS_LINUX)
+  static gboolean TimerCallback(gpointer data) {
+    instance_->TimerFired();
+    return true;
+  }
+#endif
+
+  void TimerFired() {
     ASSERT_FALSE(completed_);
 
     if (timed_out()) {
-      printf("timer fired\n");
-      KillTimer(hwnd, timer_id);
+      DestroyTimer();
       MessageLoop::current()->Quit();
       FAIL() << "fetch timed out";
       return;
     }
 
     time_elapsed_ms_ += kWaitIntervalMs;
   }
 
   static FetcherDelegate* instance_;
 
  private:
+#if defined(OS_WIN)
   UINT_PTR timer_id_;
+#elif defined(OS_LINUX)
+  guint timer_id_;
+#endif
   bool completed_;
   int time_elapsed_ms_;
   ResourceResponse response_;
   std::string data_;
 };
 
 FetcherDelegate* FetcherDelegate::instance_ = NULL;
 
 }  // namespace
 
@@ skipping 71 matching lines @@
   delegate->WaitForResponse();
 
   // When we timeout, we still call the Delegate callback but we pass in empty
   // values.
   EXPECT_TRUE(delegate->completed());
   EXPECT_TRUE(delegate->response().isNull());
   EXPECT_EQ(delegate->data(), std::string());
   EXPECT_TRUE(delegate->time_elapsed_ms() < kMaxWaitTimeMs);
 }