android: Java-based launcher thread

base/message_loop/message_loop_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_test.h"
 #include "base/pending_task.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/platform_thread.h"
@@ skipping 61 matching lines @@
   JNIEnv* env = base::android::AttachCurrentThread();
   jclass exception = env->FindClass(
       "org/chromium/base/TestSystemMessageHandler$TestException");
 
   env->ThrowNew(exception,
                 "This is a test exception that should be caught in "
                 "TestSystemMessageHandler.handleMessage");
   static_cast<base::MessageLoopForUI*>(base::MessageLoop::current())->Abort();
 }
 
-void RunTest_AbortDontRunMoreTasks(bool delayed) {
-  MessageLoop loop(MessageLoop::TYPE_JAVA);
-
+void RunTest_AbortDontRunMoreTasks(bool delayed, bool init_java_first) {
   WaitableEvent test_done_event(WaitableEvent::ResetPolicy::MANUAL,
                                 WaitableEvent::InitialState::NOT_SIGNALED);
 
-  std::unique_ptr<android::JavaHandlerThreadForTesting> java_thread;
-  java_thread.reset(new android::JavaHandlerThreadForTesting(
-      "JavaHandlerThreadForTesting from AbortDontRunMoreTasks",
-      &test_done_event));
+  std::unique_ptr<android::JavaHandlerThread> java_thread;
+  if (init_java_first) {

[gab, 2017/03/29 17:19:53]

I'm not clear on difference? The "JavaHandlerThreadForTesting from
AbortDontRunMoreTasks" changes something?

[boliu, 2017/03/29 18:02:39]

It calls a different constructor, which constructs the thread in a different
way, ie create the java object and test it can be used as a first, before
native.

Added Create methods so they can be named better to make this easier to read.
wdyt?

[gab, 2017/03/29 18:14:04]

Ah I see, yeah two constructors doing different things sure was subtle, explicit
create methods are indeed much better,

+    java_thread.reset(
+        new android::JavaHandlerThreadForTesting(&test_done_event));
+  } else {
+    java_thread.reset(new android::JavaHandlerThreadForTesting(
+        "JavaHandlerThreadForTesting from AbortDontRunMoreTasks",
+        &test_done_event));
+  }
   java_thread->Start();
 
   if (delayed) {
     java_thread->message_loop()->task_runner()->PostDelayedTask(
         FROM_HERE, Bind(&AbortMessagePump), TimeDelta::FromMilliseconds(10));
   } else {
     java_thread->message_loop()->task_runner()->PostTask(
         FROM_HERE, Bind(&AbortMessagePump));
   }
 
   // Wait to ensure we catch the correct exception (and don't crash)
   test_done_event.Wait();
 
   java_thread->Stop();
   java_thread.reset();
 }
 
 TEST(MessageLoopTest, JavaExceptionAbort) {
-  RunTest_AbortDontRunMoreTasks(false);
+  constexpr bool delayed = false;
+  constexpr bool init_java_first = false;
+  RunTest_AbortDontRunMoreTasks(delayed, init_java_first);
 }
 TEST(MessageLoopTest, DelayedJavaExceptionAbort) {
-  RunTest_AbortDontRunMoreTasks(true);
+  constexpr bool delayed = true;
+  constexpr bool init_java_first = false;
+  RunTest_AbortDontRunMoreTasks(delayed, init_java_first);
+}
+TEST(MessageLoopTest, JavaExceptionAbortInitJavaFirst) {
+  constexpr bool delayed = false;
+  constexpr bool init_java_first = true;
+  RunTest_AbortDontRunMoreTasks(delayed, init_java_first);
 }
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_WIN)
 
 // This function runs slowly to simulate a large amount of work being done.
 static void SlowFunc(TimeDelta pause, int* quit_counter) {
     PlatformThread::Sleep(pause);
     if (--(*quit_counter) == 0)
       MessageLoop::current()->QuitWhenIdle();
@@ skipping 883 matching lines @@
 
   {
     std::string kThreadName("bar");
     base::Thread thread(kThreadName);
     ASSERT_TRUE(thread.StartAndWaitForTesting());
     EXPECT_EQ(kThreadName, thread.message_loop()->GetThreadName());
   }
 }
 
 }  // namespace base