diff --git a/webrtc/base/profiler_unittest.cc b/webrtc/base/profiler_unittest.cc
index 2448fce2de..6fd4b5925e 100644
--- a/webrtc/base/profiler_unittest.cc
+++ b/webrtc/base/profiler_unittest.cc
@@ -8,19 +8,20 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/profiler.h"
+#include "webrtc/base/timedelta.h"
 #include "webrtc/base/thread.h"
 
 namespace {
 
 const int kWaitMs = 250;
 const double kWaitSec = 0.250;
-const double kTolerance = 0.1;
 
-const char* TestFunc() {
+const char* TestFunc(rtc::FakeClock* clock) {
   PROFILE_F();
-  rtc::Thread::SleepMs(kWaitMs);
+  clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
   return __FUNCTION__;
 }
 
@@ -28,33 +29,29 @@ const char* TestFunc() {
 
 namespace rtc {
 
-// Disable this test due to flakiness; see bug 5947.
-#if defined(WEBRTC_LINUX)
-#define MAYBE_TestFunction DISABLED_TestFunction
-#else
-#define MAYBE_TestFunction TestFunction
-#endif
-TEST(ProfilerTest, MAYBE_TestFunction) {
+TEST(ProfilerTest, TestFunction) {
+  rtc::ScopedFakeClock fake_clock;
   ASSERT_TRUE(Profiler::Instance()->Clear());
 
   // Profile a long-running function.
-  const char* function_name = TestFunc();
+  const char* function_name = TestFunc(&fake_clock);
   const ProfilerEvent* event = Profiler::Instance()->GetEvent(function_name);
   ASSERT_TRUE(event != NULL);
   EXPECT_FALSE(event->is_started());
   EXPECT_EQ(1, event->event_count());
-  EXPECT_NEAR(kWaitSec, event->mean(), kTolerance * 3);
+  EXPECT_EQ(kWaitSec, event->mean());
 
   // Run it a second time.
-  TestFunc();
+  TestFunc(&fake_clock);
   EXPECT_FALSE(event->is_started());
   EXPECT_EQ(2, event->event_count());
-  EXPECT_NEAR(kWaitSec, event->mean(), kTolerance);
-  EXPECT_NEAR(kWaitSec * 2, event->total_time(), kTolerance * 2);
+  EXPECT_EQ(kWaitSec, event->mean());
+  EXPECT_EQ(kWaitSec * 2, event->total_time());
   EXPECT_DOUBLE_EQ(event->mean(), event->total_time() / event->event_count());
 }
 
 TEST(ProfilerTest, TestScopedEvents) {
+  rtc::ScopedFakeClock fake_clock;
   const std::string kEvent1Name = "Event 1";
   const std::string kEvent2Name = "Event 2";
   const int kEvent2WaitMs = 150;
@@ -68,40 +65,39 @@ TEST(ProfilerTest, TestScopedEvents) {
     ASSERT_TRUE(event1 != NULL);
     EXPECT_TRUE(event1->is_started());
     EXPECT_EQ(0, event1->event_count());
-    rtc::Thread::SleepMs(kWaitMs);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
     EXPECT_TRUE(event1->is_started());
   }
   // Check the result.
   EXPECT_FALSE(event1->is_started());
   EXPECT_EQ(1, event1->event_count());
-  EXPECT_NEAR(kWaitSec, event1->mean(), kTolerance);
+  EXPECT_EQ(kWaitSec, event1->mean());
   {  // Profile a second event.
     PROFILE(kEvent2Name);
     event2 = Profiler::Instance()->GetEvent(kEvent2Name);
     ASSERT_TRUE(event2 != NULL);
     EXPECT_FALSE(event1->is_started());
     EXPECT_TRUE(event2->is_started());
-    rtc::Thread::SleepMs(kEvent2WaitMs);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kEvent2WaitMs));
   }
   // Check the result.
   EXPECT_FALSE(event2->is_started());
   EXPECT_EQ(1, event2->event_count());
 
-  // The difference here can be as much as 0.33, so we need high tolerance.
-  EXPECT_NEAR(kEvent2WaitSec, event2->mean(), kTolerance * 4);
+  EXPECT_EQ(kEvent2WaitSec, event2->mean());
   // Make sure event1 is unchanged.
   EXPECT_FALSE(event1->is_started());
   EXPECT_EQ(1, event1->event_count());
   {  // Run another event 1.
     PROFILE(kEvent1Name);
     EXPECT_TRUE(event1->is_started());
-    rtc::Thread::SleepMs(kWaitMs);
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kWaitMs));
   }
   // Check the result.
   EXPECT_FALSE(event1->is_started());
   EXPECT_EQ(2, event1->event_count());
-  EXPECT_NEAR(kWaitSec, event1->mean(), kTolerance);
-  EXPECT_NEAR(kWaitSec * 2, event1->total_time(), kTolerance * 2);
+  EXPECT_EQ(kWaitSec, event1->mean());
+  EXPECT_EQ(kWaitSec * 2, event1->total_time());
   EXPECT_DOUBLE_EQ(event1->mean(),
                    event1->total_time() / event1->event_count());
 }