scheduler: Tell v8 about the current RAIL mode

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 <utility>
@@ skipping 423 matching lines @@
   attributes.lose_context_when_out_of_memory = true;
   const bool automatic_flushes = false;
   return make_scoped_refptr(new ContextProviderCommandBuffer(
       std::move(gpu_channel_host), stream_id, stream_priority,
       gpu::kNullSurfaceHandle,
       GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext"),
       gl::PreferIntegratedGpu, automatic_flushes, support_locking, limits,
       attributes, nullptr, type));
 }
 
+void SetRAILModeOnWorker(v8::RAILMode rail_mode) {
+  if (v8::Isolate* isolate = v8::Isolate::GetCurrent())

[jochen (gone - plz use gerrit), 2016/06/28 13:20:58]

the latest and greatest is introducing helper functions like
blink::MemoryPressureNotificationToWorkerThreadIsolates

[Sami, 2016/06/28 13:53:18]

I am now aligned with the latest and greatest trends.

With this change I'm now setting the RAIL mode from a thread different from the
one owning the isolate. Hannes/Ulan/Michael, is that okay?

+    isolate->SetRAILMode(rail_mode);
+}
+
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   ~MemoryObserver() override {}
 
   void WillProcessTask(const base::PendingTask& pending_task) override {}
 
@@ skipping 487 matching lines @@
   shared_main_thread_contexts_ = nullptr;
 
   if (gpu_channel_.get())
     gpu_channel_->DestroyChannel();
 
   ChildThreadImpl::Shutdown();
 
   // Shut down the message loop and the renderer scheduler before shutting down
   // Blink. This prevents a scenario where a pending task in the message loop
   // accesses Blink objects after Blink shuts down.
+  renderer_scheduler_->SetRAILModeObserver(nullptr);
   renderer_scheduler_->Shutdown();
   if (main_message_loop_)
     main_message_loop_->RunUntilIdle();
 
   if (blink_platform_impl_) {
     blink_platform_impl_->Shutdown();
     // This must be at the very end of the shutdown sequence.
     // blink::shutdown() must be called after all strong references from
     // Chromium to Blink are cleared.
     blink::shutdown();
@@ skipping 193 matching lines @@
   SetRuntimeFeaturesDefaultsAndUpdateFromArgs(command_line);
 
   blink_platform_impl_.reset(new RendererBlinkPlatformImpl(
       renderer_scheduler_.get(),
       GetRemoteInterfaces()->GetWeakPtr()));
   blink::initialize(blink_platform_impl_.get());
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
   isolate->SetCreateHistogramFunction(CreateHistogram);
   isolate->SetAddHistogramSampleFunction(AddHistogramSample);
+  renderer_scheduler_->SetRAILModeObserver(this);
 
   main_thread_compositor_task_runner_ =
       renderer_scheduler_->CompositorTaskRunner();
 
   main_input_callback_.Reset(
       base::Bind(base::IgnoreResult(&RenderThreadImpl::OnMessageReceived),
                  base::Unretained(this)));
 
   scoped_refptr<base::SingleThreadTaskRunner> resource_task_queue2;
   if (resource_task_queue) {
@@ skipping 447 matching lines @@
 }
 
 bool RenderThreadImpl::AreImageDecodeTasksEnabled() {
   return are_image_decode_tasks_enabled_;
 }
 
 bool RenderThreadImpl::IsThreadedAnimationEnabled() {
   return is_threaded_animation_enabled_;
 }
 
+void RenderThreadImpl::OnRAILModeChanged(v8::RAILMode rail_mode) {
+  blink::mainThreadIsolate()->SetRAILMode(rail_mode);
+  WorkerThreadRegistry::Instance()->PostTaskToAllThreads(
+      base::Bind(&SetRAILModeOnWorker, rail_mode));
+}
+
 bool RenderThreadImpl::IsMainThread() {
   return !!current();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetIOThreadTaskRunner() {
   return io_thread_task_runner_;
 }
 
 std::unique_ptr<base::SharedMemory> RenderThreadImpl::AllocateSharedMemory(
@@ skipping 566 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content