Repo created

TMessagesProj/jni/voip/webrtc/base/android/task_scheduler/post_task_android.cc

@@ -0,0 +1,88 @@
+// Copyright 2018 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/android/task_scheduler/post_task_android.h"
+
+#include "base/android_runtime_jni_headers/Runnable_jni.h"
+#include "base/base_jni_headers/PostTask_jni.h"
+#include "base/no_destructor.h"
+#include "base/run_loop.h"
+#include "base/task/post_task.h"
+#include "base/task/thread_pool/thread_pool_instance.h"
+
+namespace base {
+
+// static
+void PostTaskAndroid::SignalNativeSchedulerReady() {
+  Java_PostTask_onNativeSchedulerReady(base::android::AttachCurrentThread());
+}
+
+// static
+void PostTaskAndroid::SignalNativeSchedulerShutdownForTesting() {
+  Java_PostTask_onNativeSchedulerShutdownForTesting(
+      base::android::AttachCurrentThread());
+}
+
+namespace {
+std::array<uint8_t, TaskTraitsExtensionStorage::kStorageSize> GetExtensionData(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jbyteArray>& array_object) {
+  if (env->IsSameObject(array_object, nullptr))
+    return std::array<uint8_t, TaskTraitsExtensionStorage::kStorageSize>();
+
+  jbyteArray array = static_cast<jbyteArray>(array_object);
+  DCHECK_EQ(env->GetArrayLength(array),
+            static_cast<jsize>(TaskTraitsExtensionStorage::kStorageSize));
+
+  std::array<uint8_t, TaskTraitsExtensionStorage::kStorageSize> result;
+  jbyte* src_bytes = env->GetByteArrayElements(array, nullptr);
+  memcpy(&result[0], src_bytes, TaskTraitsExtensionStorage::kStorageSize);
+  env->ReleaseByteArrayElements(array, src_bytes, JNI_ABORT);
+  return result;
+}
+}  // namespace
+
+// static
+TaskTraits PostTaskAndroid::CreateTaskTraits(
+    JNIEnv* env,
+    jint priority,
+    jboolean may_block,
+    jboolean use_thread_pool,
+    jbyte extension_id,
+    const base::android::JavaParamRef<jbyteArray>& extension_data) {
+  return TaskTraits(static_cast<TaskPriority>(priority), may_block,
+                    use_thread_pool,
+                    TaskTraitsExtensionStorage(
+                        extension_id, GetExtensionData(env, extension_data)));
+}
+
+void JNI_PostTask_PostDelayedTask(
+    JNIEnv* env,
+    jint priority,
+    jboolean may_block,
+    jboolean use_thread_pool,
+    jbyte extension_id,
+    const base::android::JavaParamRef<jbyteArray>& extension_data,
+    const base::android::JavaParamRef<jobject>& task,
+    jlong delay) {
+  // This could be run on any java thread, so we can't cache |env| in the
+  // BindOnce because JNIEnv is thread specific.
+  PostDelayedTask(FROM_HERE,
+                  PostTaskAndroid::CreateTaskTraits(
+                      env, priority, may_block, use_thread_pool, extension_id,
+                      extension_data),
+                  BindOnce(&PostTaskAndroid::RunJavaTask,
+                           base::android::ScopedJavaGlobalRef<jobject>(task)),
+                  TimeDelta::FromMilliseconds(delay));
+}
+
+// static
+void PostTaskAndroid::RunJavaTask(
+    base::android::ScopedJavaGlobalRef<jobject> task) {
+  // JNIEnv is thread specific, but we don't know which thread we'll be run on
+  // so we must look it up.
+  JNI_Runnable::Java_Runnable_run(base::android::AttachCurrentThread(), task);
+}
+
+}  // namespace base

TMessagesProj/jni/voip/webrtc/base/android/task_scheduler/post_task_android.h

@@ -0,0 +1,42 @@
+// Copyright 2018 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.
+
+#ifndef BASE_ANDROID_TASK_SCHEDULER_POST_TASK_ANDROID_H_
+#define BASE_ANDROID_TASK_SCHEDULER_POST_TASK_ANDROID_H_
+
+#include "base/android/jni_weak_ref.h"
+#include "base/base_export.h"
+#include "base/task/task_traits.h"
+
+namespace base {
+
+// C++ interface for PostTask.java
+class BASE_EXPORT PostTaskAndroid {
+ public:
+  // Routes tasks posted via the Java PostTask APIs through the C++ PostTask
+  // APIs. Invoked once the C++ PostTask APIs are fully initialized.
+  static void SignalNativeSchedulerReady();
+
+  // Signals that the C++ PostTask APIs have shutdown. Needed to make unit tests
+  // that repeatedly create and destroy the scheduler work.
+  static void SignalNativeSchedulerShutdownForTesting();
+
+  static TaskTraits CreateTaskTraits(
+      JNIEnv* env,
+      jint priority,
+      jboolean may_block,
+      jboolean use_thread_pool,
+      jbyte extension_id,
+      const base::android::JavaParamRef<jbyteArray>& extension_data);
+
+  // We don't know ahead of time which thread this will run on so it looks up
+  // the JNI environment and the bindings dynamically (albeit with caching).
+  static void RunJavaTask(base::android::ScopedJavaGlobalRef<jobject> task);
+
+  DISALLOW_COPY_AND_ASSIGN(PostTaskAndroid);
+};
+
+}  // namespace base
+
+#endif  // BASE_ANDROID_TASK_SCHEDULER_POST_TASK_ANDROID_H_

TMessagesProj/jni/voip/webrtc/base/android/task_scheduler/task_runner_android.cc

@@ -0,0 +1,73 @@
+// Copyright 2018 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/android/task_scheduler/task_runner_android.h"
+
+#include "base/android/task_scheduler/post_task_android.h"
+#include "base/base_jni_headers/TaskRunnerImpl_jni.h"
+#include "base/bind.h"
+#include "base/run_loop.h"
+#include "base/task/post_task.h"
+#include "base/time/time.h"
+
+namespace base {
+
+jlong JNI_TaskRunnerImpl_Init(
+    JNIEnv* env,
+    jint task_runner_type,
+    jint priority,
+    jboolean may_block,
+    jboolean thread_pool,
+    jbyte extension_id,
+    const base::android::JavaParamRef<jbyteArray>& extension_data) {
+  TaskTraits task_traits = PostTaskAndroid::CreateTaskTraits(
+      env, priority, may_block, thread_pool, extension_id, extension_data);
+  scoped_refptr<TaskRunner> task_runner;
+  switch (static_cast<TaskRunnerType>(task_runner_type)) {
+    case TaskRunnerType::BASE:
+      task_runner = CreateTaskRunner(task_traits);
+      break;
+    case TaskRunnerType::SEQUENCED:
+      task_runner = CreateSequencedTaskRunner(task_traits);
+      break;
+    case TaskRunnerType::SINGLE_THREAD:
+      task_runner = CreateSingleThreadTaskRunner(task_traits);
+      break;
+  }
+  return reinterpret_cast<intptr_t>(new TaskRunnerAndroid(
+      task_runner, static_cast<TaskRunnerType>(task_runner_type)));
+}
+
+TaskRunnerAndroid::TaskRunnerAndroid(scoped_refptr<TaskRunner> task_runner,
+                                     TaskRunnerType type)
+    : task_runner_(std::move(task_runner)), type_(type) {}
+
+TaskRunnerAndroid::~TaskRunnerAndroid() = default;
+
+void TaskRunnerAndroid::Destroy(JNIEnv* env) {
+  // This could happen on any thread.
+  delete this;
+}
+
+void TaskRunnerAndroid::PostDelayedTask(
+    JNIEnv* env,
+    const base::android::JavaRef<jobject>& task,
+    jlong delay) {
+  task_runner_->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(&PostTaskAndroid::RunJavaTask,
+                     base::android::ScopedJavaGlobalRef<jobject>(task)),
+      TimeDelta::FromMilliseconds(delay));
+}
+
+bool TaskRunnerAndroid::BelongsToCurrentThread(JNIEnv* env) {
+  // TODO(crbug.com/1026641): Move BelongsToCurrentThread from TaskRunnerImpl to
+  // SequencedTaskRunnerImpl on the Java side too.
+  if (type_ == TaskRunnerType::BASE)
+    return false;
+  return static_cast<SequencedTaskRunner*>(task_runner_.get())
+      ->RunsTasksInCurrentSequence();
+}
+
+}  // namespace base

TMessagesProj/jni/voip/webrtc/base/android/task_scheduler/task_runner_android.h

@@ -0,0 +1,41 @@
+// Copyright 2018 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.
+
+#ifndef BASE_ANDROID_TASK_SCHEDULER_TASK_RUNNER_ANDROID_H_
+#define BASE_ANDROID_TASK_SCHEDULER_TASK_RUNNER_ANDROID_H_
+
+#include "base/android/jni_weak_ref.h"
+#include "base/single_thread_task_runner.h"
+
+namespace base {
+
+// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base.task
+enum class TaskRunnerType { BASE, SEQUENCED, SINGLE_THREAD };
+
+// Native implementation backing TaskRunnerImpl.java which posts java tasks onto
+// a C++ TaskRunner.
+class TaskRunnerAndroid {
+ public:
+  explicit TaskRunnerAndroid(scoped_refptr<TaskRunner> task_runner,
+                             TaskRunnerType type);
+  ~TaskRunnerAndroid();
+
+  void Destroy(JNIEnv* env);
+
+  void PostDelayedTask(JNIEnv* env,
+                       const base::android::JavaRef<jobject>& task,
+                       jlong delay);
+
+  bool BelongsToCurrentThread(JNIEnv* env);
+
+ private:
+  const scoped_refptr<TaskRunner> task_runner_;
+  const TaskRunnerType type_;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskRunnerAndroid);
+};
+
+}  // namespace base
+
+#endif  // BASE_ANDROID_TASK_SCHEDULER_TASK_RUNNER_ANDROID_H_