Make a fairer combined message loop

base/message_loop/message_pump_android.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 "base/message_loop/message_pump_android.h"
 
 #include <jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "jni/SystemMessageHandler_jni.h"
 
 using base::android::ScopedJavaLocalRef;
 
 // ----------------------------------------------------------------------------
 // Native JNI methods called by Java.
 // ----------------------------------------------------------------------------
 // This method can not move to anonymous namespace as it has been declared as
 // 'static' in system_message_handler_jni.h.
-static jboolean DoRunLoopOnce(JNIEnv* env, jobject obj, jint native_delegate) {
+static void DoRunLoopOnce(JNIEnv* env, jobject obj, jint native_delegate) {
   base::MessagePump::Delegate* delegate =
       reinterpret_cast<base::MessagePump::Delegate*>(native_delegate);
   DCHECK(delegate);
   // This is based on MessagePumpForUI::DoRunLoop() from desktop.
   // Note however that our system queue is handled in the java side.
   // In desktop we inspect and process a single system message and then
   // we call DoWork() / DoDelayedWork().
   // On Android, the java message queue may contain messages for other handlers
   // that will be processed before calling here again.
-  bool more_work_is_plausible = delegate->DoWork();
+  bool did_work = delegate->DoWork();
 
   // This is the time when we need to do delayed work.
   base::TimeTicks delayed_work_time;
-  more_work_is_plausible |= delegate->DoDelayedWork(&delayed_work_time);
+  did_work |= delegate->DoDelayedWork(&delayed_work_time);
+
+  // Always call this if there is a delayed message waiting in the queue
+  // since is at most one delayed message in the Java message handler, and this
+  // function call may be the result of that message being handled.
+  if (!delayed_work_time.is_null()) {
+    Java_SystemMessageHandler_setDelayedTimer(env, obj,
+        (delayed_work_time - base::TimeTicks::Now()).InMillisecondsRoundedUp());
+  }
 
   // This is a major difference between android and other platforms: since we
   // can't inspect it and process just one single message, instead we'll yeld
-  // the callstack, and post a message to call us back soon.
-  if (more_work_is_plausible)
-    return true;
+  // the callstack.
+  if (did_work)
+    return;
 
-  more_work_is_plausible = delegate->DoIdleWork();
-  if (!more_work_is_plausible && !delayed_work_time.is_null()) {
-    // We only set the timer here as returning true would post a message.
-    jlong millis =
-        (delayed_work_time - base::TimeTicks::Now()).InMillisecondsRoundedUp();
-    Java_SystemMessageHandler_setDelayedTimer(env, obj, millis);
-  }
-  return more_work_is_plausible;
+  delegate->DoIdleWork();
 }
 
 namespace base {
 
 MessagePumpForUI::MessagePumpForUI()
     : run_loop_(NULL) {
 }
 
 MessagePumpForUI::~MessagePumpForUI() {
 }
@@ skipping 59 matching lines @@
   Java_SystemMessageHandler_setDelayedTimer(env,
       system_message_handler_obj_.obj(), millis);
 }
 
 // static
 bool MessagePumpForUI::RegisterBindings(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace base