Experimental: Remove chromium shared timers

content/child/blink_platform_impl.cc

 // Copyright 2014 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/child/blink_platform_impl.h"
 
 #include <math.h>
 
 #include <vector>
 
@@ skipping 394 matching lines @@
     // coverage when we add a new symbol to WebLocalizedString.h in WebKit.
     // After a planned WebKit patch is landed, we need to add a case statement
     // for the added symbol here.
     default:
       break;
   }
   return -1;
 }
 
 BlinkPlatformImpl::BlinkPlatformImpl()
-    : main_thread_task_runner_(base::MessageLoopProxy::current()),
-      shared_timer_func_(NULL),
-      shared_timer_fire_time_(0.0),
-      shared_timer_fire_time_was_set_while_suspended_(false),
-      shared_timer_suspended_(0) {
+    : main_thread_task_runner_(base::MessageLoopProxy::current()) {
   InternalInit();
 }
 
 BlinkPlatformImpl::BlinkPlatformImpl(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
-    : main_thread_task_runner_(main_thread_task_runner),
-      shared_timer_func_(NULL),
-      shared_timer_fire_time_(0.0),
-      shared_timer_fire_time_was_set_while_suspended_(false),
-      shared_timer_suspended_(0) {
+    : main_thread_task_runner_(main_thread_task_runner) {
   // TODO(alexclarke): Use c++11 delegated constructors when allowed.
   InternalInit();
 }
 
 void BlinkPlatformImpl::InternalInit() {
   // ChildThread may not exist in some tests.
   if (ChildThreadImpl::current()) {
     geofencing_provider_.reset(new WebGeofencingProviderImpl(
         ChildThreadImpl::current()->thread_safe_sender()));
     bluetooth_.reset(
         new WebBluetoothImpl(ChildThreadImpl::current()->thread_safe_sender()));
     thread_safe_sender_ = ChildThreadImpl::current()->thread_safe_sender();
     notification_dispatcher_ =
         ChildThreadImpl::current()->notification_dispatcher();
     push_dispatcher_ = ChildThreadImpl::current()->push_dispatcher();
   }
-
-  if (main_thread_task_runner_.get()) {
-    shared_timer_.SetTaskRunner(main_thread_task_runner_);
-  }
 }
 
 void BlinkPlatformImpl::UpdateWebThreadTLS(blink::WebThread* thread) {
   DCHECK(!current_thread_slot_.Get());
   current_thread_slot_.Set(thread);
 }
 
 BlinkPlatformImpl::~BlinkPlatformImpl() {
 }
 
@@ skipping 508 matching lines @@
 double BlinkPlatformImpl::monotonicallyIncreasingTime() {
   return base::TimeTicks::Now().ToInternalValue() /
       static_cast<double>(base::Time::kMicrosecondsPerSecond);
 }
 
 void BlinkPlatformImpl::cryptographicallyRandomValues(
     unsigned char* buffer, size_t length) {
   base::RandBytes(buffer, length);
 }
 
-void BlinkPlatformImpl::setSharedTimerFiredFunction(void (*func)()) {
-  shared_timer_func_ = func;
-}
-
-void BlinkPlatformImpl::setSharedTimerFireInterval(
-    double interval_seconds) {
-  shared_timer_fire_time_ = interval_seconds + monotonicallyIncreasingTime();
-  if (shared_timer_suspended_) {
-    shared_timer_fire_time_was_set_while_suspended_ = true;
-    return;
-  }
-
-  // By converting between double and int64 representation, we run the risk
-  // of losing precision due to rounding errors. Performing computations in
-  // microseconds reduces this risk somewhat. But there still is the potential
-  // of us computing a fire time for the timer that is shorter than what we
-  // need.
-  // As the event loop will check event deadlines prior to actually firing
-  // them, there is a risk of needlessly rescheduling events and of
-  // needlessly looping if sleep times are too short even by small amounts.
-  // This results in measurable performance degradation unless we use ceil() to
-  // always round up the sleep times.
-  int64 interval = static_cast<int64>(
-      ceil(interval_seconds * base::Time::kMillisecondsPerSecond)
-      * base::Time::kMicrosecondsPerMillisecond);
-
-  if (interval < 0)
-    interval = 0;
-
-  shared_timer_.Stop();
-  shared_timer_.Start(FROM_HERE, base::TimeDelta::FromMicroseconds(interval),
-                      this, &BlinkPlatformImpl::DoTimeout);
-  OnStartSharedTimer(base::TimeDelta::FromMicroseconds(interval));
-}
-
-void BlinkPlatformImpl::stopSharedTimer() {
-  shared_timer_.Stop();
-}
-
 void BlinkPlatformImpl::callOnMainThread(
     void (*func)(void*), void* context) {
   main_thread_task_runner_->PostTask(FROM_HERE, base::Bind(func, context));
 }
 
 blink::WebGestureCurve* BlinkPlatformImpl::createFlingAnimationCurve(
     blink::WebGestureDevice device_source,
     const blink::WebFloatPoint& velocity,
     const blink::WebSize& cumulative_scroll) {
   bool is_main_thread =
@@ skipping 177 matching lines @@
   // be reserved for direct use by certain hardware. Thus, we set the limit so
   // that 1.6GB of reported physical memory on a 2GB device is enough to set the
   // limit at 16M pixels, which is a desirable value since 4K*4K is a relatively
   // common texture size.
   return base::SysInfo::AmountOfPhysicalMemory() / 25;
 #else
   return noDecodedImageByteLimit;
 #endif
 }
 
-void BlinkPlatformImpl::SuspendSharedTimer() {
-  ++shared_timer_suspended_;
-}
-
-void BlinkPlatformImpl::ResumeSharedTimer() {
-  DCHECK_GT(shared_timer_suspended_, 0);
-
-  // The shared timer may have fired or been adjusted while we were suspended.
-  if (--shared_timer_suspended_ == 0 &&
-      (!shared_timer_.IsRunning() ||
-       shared_timer_fire_time_was_set_while_suspended_)) {
-    shared_timer_fire_time_was_set_while_suspended_ = false;
-    setSharedTimerFireInterval(
-        shared_timer_fire_time_ - monotonicallyIncreasingTime());
-  }
-}
-
 scoped_refptr<base::SingleThreadTaskRunner>
 BlinkPlatformImpl::MainTaskRunnerForCurrentThread() {
   if (main_thread_task_runner_.get() &&
       main_thread_task_runner_->BelongsToCurrentThread()) {
     return main_thread_task_runner_;
   } else {
     return base::MessageLoopProxy::current();
   }
 }
 
 WebString BlinkPlatformImpl::domCodeStringFromEnum(int dom_code) {
   return WebString::fromUTF8(ui::KeycodeConverter::DomCodeToCodeString(
       static_cast<ui::DomCode>(dom_code)));
 }
 
 int BlinkPlatformImpl::domEnumFromCodeString(const WebString& code) {
   return static_cast<int>(ui::KeycodeConverter::CodeStringToDomCode(
       code.utf8().data()));
 }
 
 }  // namespace content