Eliminate platform specific timer code.

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 "webkit/glue/resource_fetcher.h"
 
 #include "base/callback.h"
 #include "base/message_loop.h"
+#include "base/timer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/glue/unittest_test_server.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 #include "webkit/tools/test_shell/test_shell_test.h"
 
-#if defined(TOOLKIT_USES_GTK)
-#include <gtk/gtk.h>
-#endif
-
 using WebKit::WebFrame;
 using WebKit::WebURLResponse;
 using webkit_glue::ResourceFetcher;
 using webkit_glue::ResourceFetcherWithTimeout;
 
 namespace {
 
 class ResourceFetcherTests : public TestShellTest {
  protected:
   UnittestTestServer test_server_;
 };
 
 static const int kMaxWaitTimeMs = 5000;
-static const int kWaitIntervalMs = 100;
 
 class FetcherDelegate {
  public:
   FetcherDelegate()
-      : timer_id_(0), completed_(false), time_elapsed_ms_(0) {
+      : completed_(false),
+        timed_out_(false) {
     // 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;
-    CreateTimer(kWaitIntervalMs);
+    StartTimer();
   }
 
   ResourceFetcher::Callback* NewCallback() {
     return ::NewCallback(this, &FetcherDelegate::OnURLFetchComplete);
   }
 
   virtual void OnURLFetchComplete(const WebURLResponse& response,
                                   const std::string& data) {
     response_ = response;
     data_ = data;
     completed_ = true;
-    DestroyTimer();
+    timer_.Stop();
     MessageLoop::current()->Quit();
   }
 
   bool completed() const { return completed_; }
-  bool timed_out() const { return time_elapsed_ms_ > kMaxWaitTimeMs; }
+  bool timed_out() const { return timed_out_; }
 
-  int time_elapsed_ms() const { return time_elapsed_ms_; }
   std::string data() const { return data_; }
   const WebURLResponse& 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(TOOLKIT_USES_GTK)
-    timer_id_ = g_timeout_add(interval, &FetcherDelegate::TimerCallback, NULL);
-#elif defined(OS_MACOSX)
-    // CFAbsoluteTime is in seconds and |interval| is in ms, so make sure we
-    // keep the units correct.
-    CFTimeInterval interval_in_seconds = static_cast<double>(interval) / 1000.0;
-    CFAbsoluteTime fire_date =
-        CFAbsoluteTimeGetCurrent() + interval_in_seconds;
-    timer_id_ = CFRunLoopTimerCreate(NULL, fire_date, interval_in_seconds, 0,
-                                     0, FetcherDelegate::TimerCallback, NULL);
-    CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer_id_, kCFRunLoopCommonModes);
-#endif
+  void StartTimer() {
+    timer_.Start(base::TimeDelta::FromMilliseconds(kMaxWaitTimeMs),
+                 this,
+                 &FetcherDelegate::TimerFired);
   }
 
-  void DestroyTimer() {
-#if defined(OS_WIN)
-    ::KillTimer(NULL, timer_id_);
-#elif defined(TOOLKIT_USES_GTK)
-    g_source_remove(timer_id_);
-#elif defined(OS_MACOSX)
-    CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), timer_id_,
-                         kCFRunLoopCommonModes);
-    CFRelease(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();
-  }
-#elif defined(TOOLKIT_USES_GTK)
-  static gboolean TimerCallback(gpointer data) {
-    instance_->TimerFired();
-    return true;
-  }
-#elif defined(OS_MACOSX)
-  static void TimerCallback(CFRunLoopTimerRef timer, void* info) {
-    instance_->TimerFired();
-  }
-#endif
-
   void TimerFired() {
     ASSERT_FALSE(completed_);
 
-    if (timed_out()) {
-      DestroyTimer();
-      MessageLoop::current()->Quit();
-      FAIL() << "fetch timed out";
-      return;
-    }
-
-    time_elapsed_ms_ += kWaitIntervalMs;
+    timed_out_ = true;
+    MessageLoop::current()->Quit();
+    FAIL() << "fetch timed out";
   }
 
   static FetcherDelegate* instance_;
 
  private:
-#if defined(OS_WIN)
-  UINT_PTR timer_id_;
-#elif defined(TOOLKIT_USES_GTK)
-  guint timer_id_;
-#elif defined(OS_MACOSX)
-  CFRunLoopTimerRef timer_id_;
-#endif
+  base::OneShotTimer<FetcherDelegate> timer_;
   bool completed_;
-  int time_elapsed_ms_;
+  bool timed_out_;
   WebURLResponse response_;
   std::string data_;
 };
 
 FetcherDelegate* FetcherDelegate::instance_ = NULL;
 
 // Test a fetch from the test server.
 // Flaky, http://crbug.com/51622.
 TEST_F(ResourceFetcherTests, FLAKY_ResourceFetcherDownload) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 36 matching lines @@
   scoped_ptr<ResourceFetcher> fetcher(new ResourceFetcher(
       url, frame, delegate->NewCallback()));
 
   delegate->WaitForResponse();
 
   // When we fail, 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);
+  EXPECT_FALSE(delegate->timed_out());
 }
 
 TEST_F(ResourceFetcherTests, ResourceFetcherTimeout) {
   ASSERT_TRUE(test_server_.Start());
 
   WebFrame* frame = test_shell_->webView()->mainFrame();
 
   // Grab a page that takes at least 1 sec to respond, but set the fetcher to
   // timeout in 0 sec.
   GURL url(test_server_.GetURL("slow?1"));
   scoped_ptr<FetcherDelegate> delegate(new FetcherDelegate);
   scoped_ptr<ResourceFetcher> fetcher(new ResourceFetcherWithTimeout(
       url, frame, 0, delegate->NewCallback()));
 
   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);
+  EXPECT_FALSE(delegate->timed_out());
 }
 
 class EvilFetcherDelegate : public FetcherDelegate {
  public:
   void SetFetcher(ResourceFetcher* fetcher) {
     fetcher_.reset(fetcher);
   }
 
   void OnURLFetchComplete(const WebURLResponse& response,
                           const std::string& data) {
@@ skipping 14 matching lines @@
 
   // Grab a page that takes at least 1 sec to respond, but set the fetcher to
   // timeout in 0 sec.
   GURL url(test_server_.GetURL("slow?1"));
   scoped_ptr<EvilFetcherDelegate> delegate(new EvilFetcherDelegate);
   scoped_ptr<ResourceFetcher> fetcher(new ResourceFetcherWithTimeout(
       url, frame, 0, delegate->NewCallback()));
   delegate->SetFetcher(fetcher.release());
 
   delegate->WaitForResponse();
+  EXPECT_FALSE(delegate->timed_out());
 }
 
 }  // namespace