Forward input tasks to the Blink scheduler

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>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_table.h"
 #include "base/path_service.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "cc/base/switches.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "content/child/appcache/appcache_dispatcher.h"
@@ skipping 67 matching lines @@
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_forwarding_message_filter.h"
 #include "ipc/ipc_platform_file.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/media.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 #include "mojo/common/common_type_converters.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "skia/ext/event_tracer_impl.h"
+#include "third_party/WebKit/public/platform/WebSchedulerProxy.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/WebThread.h"
+#include "third_party/WebKit/public/platform/WebTraceLocation.h"
 #include "third_party/WebKit/public/web/WebColorName.h"
 #include "third_party/WebKit/public/web/WebDatabase.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebImageCache.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
 #include "third_party/WebKit/public/web/WebPopupMenu.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebScriptController.h"
@@ skipping 169 matching lines @@
     frame->BindServiceRegistry(request.PassMessagePipe());
   }
 };
 
 void CreateRenderFrameSetup(mojo::InterfaceRequest<RenderFrameSetup> request) {
   mojo::BindToRequest(new RenderFrameSetupImpl(), &request);
 }
 
 }  // namespace
 
+class SchedulerProxyTaskRunnerBase : public base::SingleThreadTaskRunner {
+ public:
+  SchedulerProxyTaskRunnerBase()
+      : main_thread_id_(base::PlatformThread::CurrentId()),
+        scheduler_proxy_(blink::WebSchedulerProxy::create()),
+        fallback_task_runner_(base::MessageLoopProxy::current()),
+        is_active_(true) {}
+
+  // base::SingleThreadTaskRunner implementation:
+  virtual bool RunsTasksOnCurrentThread() const OVERRIDE {
+    return base::PlatformThread::CurrentId() == main_thread_id_;
+  }
+
+  void Shutdown() {
+    base::AutoLock lock(scheduler_lock_);
+    is_active_ = false;
+  }
+
+ protected:
+  virtual ~SchedulerProxyTaskRunnerBase() {}
+
+  const base::PlatformThreadId main_thread_id_;
+  blink::WebSchedulerProxy scheduler_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> fallback_task_runner_;
+
+  bool is_active_;
+  base::Lock scheduler_lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(SchedulerProxyTaskRunnerBase);
+};
+
+// Helper for forwarding posted tasks into different WebSchedulerProxy queues.
+template <void (blink::WebSchedulerProxy::*ProxyFunction)(
+    const blink::WebTraceLocation&,
+    blink::WebThread::Task*)>
+class SchedulerProxyTaskRunner : public SchedulerProxyTaskRunnerBase {
+ public:
+  SchedulerProxyTaskRunner() {}
+
+  // base::SingleThreadTaskRunner implementation:
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const base::Closure& task,
+                               base::TimeDelta delay) OVERRIDE {
+    DCHECK(delay == base::TimeDelta());
+    base::AutoLock lock(scheduler_lock_);
+    if (!is_active_)
+      return fallback_task_runner_->PostDelayedTask(from_here, task, delay);

[jamesr, 2014/08/07 17:59:24]

why do you have a fallback? when is it used? are there tests that exercise it?

[Sami, 2014/08/08 11:39:16]

I added it as a safe guard based on your comment #6, but now that I took a
closer look at the shutdown sequence I don't think it is actually needed. This
task runner is used by the input event filter and the impl thread, both of which
get torn down before we call blink::shutdown().

I've removed the fallback and added a DCHECK here.

+    blink::WebTraceLocation location(from_here.function_name(),
+                                     from_here.file_name());
+    (scheduler_proxy_.*ProxyFunction)(location, new TaskAdapter(task));
+    return true;
+  }
+
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      base::TimeDelta delay) OVERRIDE {
+    NOTREACHED();
+    return false;
+  }
+
+ protected:
+  virtual ~SchedulerProxyTaskRunner() {}
+
+ private:
+  class TaskAdapter : public blink::WebThread::Task {
+   public:
+    explicit TaskAdapter(const base::Closure& function) : function_(function) {}
+    virtual ~TaskAdapter() {}
+
+    virtual void run() OVERRIDE { function_.Run(); }
+
+   private:
+    base::Closure function_;
+  };
+
+  DISALLOW_COPY_AND_ASSIGN(SchedulerProxyTaskRunner);
+};
+
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   virtual ~MemoryObserver() {}
 
   virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
   }
 
   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
@@ skipping 319 matching lines @@
 
   // RemoveEmbeddedWorkerRoute may be called while deleting
   // EmbeddedWorkerDispatcher. So it must be deleted before deleting
   // RenderThreadImpl.
   embedded_worker_dispatcher_.reset();
 
   // Ramp down IDB before we ramp down WebKit (and V8), since IDB classes might
   // hold pointers to V8 objects (e.g., via pending requests).
   main_thread_indexed_db_dispatcher_.reset();
 
+  // Stop forwarding tasks to the Blink scheduler.
+  main_thread_compositor_task_runner_->Shutdown();
+  main_thread_input_task_runner_->Shutdown();
+
   if (webkit_platform_support_)
     blink::shutdown();
 
   lazy_tls.Pointer()->Set(NULL);
 
   // TODO(port)
 #if defined(OS_WIN)
   // Clean up plugin channels before this thread goes away.
   NPChannelBase::CleanupChannels();
 #endif
@@ skipping 162 matching lines @@
     ResourceDispatcherDelegate* delegate) {
   resource_dispatcher()->set_delegate(delegate);
 }
 
 void RenderThreadImpl::EnsureWebKitInitialized() {
   if (webkit_platform_support_)
     return;
 
   webkit_platform_support_.reset(new RendererWebKitPlatformSupportImpl);
   blink::initialize(webkit_platform_support_.get());
+  main_thread_compositor_task_runner_ =
+      make_scoped_refptr(new SchedulerProxyTaskRunner<
+          &blink::WebSchedulerProxy::postCompositorTask>());
+  main_thread_input_task_runner_ = make_scoped_refptr(
+      new SchedulerProxyTaskRunner<&blink::WebSchedulerProxy::postInputTask>());
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
 
   isolate->SetCounterFunction(base::StatsTable::FindLocation);
   isolate->SetCreateHistogramFunction(CreateHistogram);
   isolate->SetAddHistogramSampleFunction(AddHistogramSample);
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   bool enable = !command_line.HasSwitch(switches::kDisableThreadedCompositing);
@@ skipping 19 matching lines @@
     }
 
     InputHandlerManagerClient* input_handler_manager_client = NULL;
 #if defined(OS_ANDROID)
     if (SynchronousCompositorFactory* factory =
         SynchronousCompositorFactory::GetInstance()) {
       input_handler_manager_client = factory->GetInputHandlerManagerClient();
     }
 #endif
     if (!input_handler_manager_client) {
-      input_event_filter_ =
-          new InputEventFilter(this, compositor_message_loop_proxy_);
+      input_event_filter_ = new InputEventFilter(
+          this, main_thread_input_task_runner_, compositor_message_loop_proxy_);
       AddFilter(input_event_filter_.get());
       input_handler_manager_client = input_event_filter_.get();
     }
     input_handler_manager_.reset(
         new InputHandlerManager(compositor_message_loop_proxy_,
                                 input_handler_manager_client));
   }
 
   scoped_refptr<base::MessageLoopProxy> output_surface_loop;
   if (enable)
@@ skipping 695 matching lines @@
     media_thread_->Start();
 
 #if defined(OS_ANDROID)
     renderer_demuxer_ = new RendererDemuxerAndroid();
     AddFilter(renderer_demuxer_.get());
 #endif
   }
   return media_thread_->message_loop_proxy();
 }
 
+scoped_refptr<base::SingleThreadTaskRunner>
+RenderThreadImpl::MainThreadCompositorTaskRunner() const {
+  return main_thread_compositor_task_runner_;
+}
+
 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(blink::WebGamepads* data) {
   gamepad_shared_memory_reader_->SampleGamepads(*data);
@@ skipping 26 matching lines @@
   hidden_widget_count_--;
 
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     return;
   }
 
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 }  // namespace content