Use IO loop for the compositor and media threads in the renderer on posix.

content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 651 matching lines @@
   bool enable = command_line.HasSwitch(switches::kEnableThreadedCompositing);
   if (enable) {
 #if defined(OS_ANDROID)
     if (SynchronousCompositorFactory* factory =
         SynchronousCompositorFactory::GetInstance())
       compositor_message_loop_proxy_ =
           factory->GetCompositorMessageLoop();
 #endif
     if (!compositor_message_loop_proxy_.get()) {
       compositor_thread_.reset(new base::Thread("Compositor"));
+#if defined(OS_POSIX)
+      // Workaround for crbug.com/293736
+      // On Posix, MessagePumpDefault uses system time, so delayed tasks (for
+      // compositor scheduling) work incorrectly across system time changes
+      // (e.g.  tlsdate). So instead, use an IO loop, which uses libevent, that
+      // uses monotonic time (immune to these problems).
+      base::Thread::Options options;
+      options.message_loop_type = base::MessageLoop::TYPE_IO;
+      compositor_thread_->StartWithOptions(options);
+#else
       compositor_thread_->Start();
+#endif
 #if defined(OS_ANDROID)
       compositor_thread_->SetPriority(base::kThreadPriority_Display);
 #endif
       compositor_message_loop_proxy_ =
           compositor_thread_->message_loop_proxy();
       compositor_message_loop_proxy_->PostTask(
           FROM_HERE,
           base::Bind(base::IgnoreResult(&ThreadRestrictions::SetIOAllowed),
                      false));
     }
@@ skipping 604 matching lines @@
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }
 
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetMediaThreadMessageLoopProxy() {
   DCHECK(message_loop() == base::MessageLoop::current());
   if (!media_thread_) {
     media_thread_.reset(new base::Thread("Media"));
+#if defined(OS_POSIX)
+    // Workaround for crbug.com/293736
+    // On Posix, MessagePumpDefault uses system time, so delayed tasks (for
+    // compositor scheduling) work incorrectly across system time changes
+    // (e.g.  tlsdate). So instead, use an IO loop, which uses libevent, that
+    // uses monotonic time (immune to these problems).
+    base::Thread::Options options;
+    options.message_loop_type = base::MessageLoop::TYPE_IO;
+    media_thread_->StartWithOptions(options);
+#else
     media_thread_->Start();
+#endif
   }
   return media_thread_->message_loop_proxy();
 }
 
 void RenderThreadImpl::SetFlingCurveParameters(
     const std::vector<float>& new_touchpad,
     const std::vector<float>& new_touchscreen) {
   webkit_platform_support_->SetFlingCurveParameters(new_touchpad,
                                                     new_touchscreen);
 
 }
 
 void RenderThreadImpl::SampleGamepads(WebKit::WebGamepads* data) {
   if (!gamepad_shared_memory_reader_)
     gamepad_shared_memory_reader_.reset(new GamepadSharedMemoryReader);
   gamepad_shared_memory_reader_->SampleGamepads(*data);
 }
 
 }  // namespace content