Move WakeUpGpu logic to GpuChannelManager

content/common/gpu/gpu_channel_manager.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/common/gpu/gpu_channel_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
 
 namespace content {
 
+namespace {
+#if defined(OS_ANDROID)
+// Amount of time the GPU is allowed to idle before it powers down.

[no sievers, 2015/09/23 19:32:33]

nit: while you're at it, can you rephrase it since it's really an assumption
about the GPU/driver power management. maybe 'Amount of time we expect the GPU
to stay powered up without being used.'?

[piman, 2015/09/23 22:32:32]

Done.

+const int kMaxGpuIdleTimeMs = 40;
+// Maximum amount of time we keep pinging the GPU waiting for the client to
+// draw.
+const int kMaxKeepAliveTimeMs = 200;
+#endif
+
+}
+
 GpuChannelManager::GpuChannelManager(
     IPC::SyncChannel* channel,
     GpuWatchdog* watchdog,
     base::SingleThreadTaskRunner* task_runner,
     base::SingleThreadTaskRunner* io_task_runner,
     base::WaitableEvent* shutdown_event,
     gpu::SyncPointManager* sync_point_manager,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : task_runner_(task_runner),
       io_task_runner_(io_task_runner),
@@ skipping 71 matching lines @@
 bool GpuChannelManager::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannelManager, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
     IPC_MESSAGE_HANDLER(GpuMsg_UpdateValueState, OnUpdateValueState)
+#if defined(OS_ANDROID)
+    IPC_MESSAGE_HANDLER(GpuMsg_WakeUpGpu, OnWakeUpGpu);
+#endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool GpuChannelManager::OnMessageReceived(const IPC::Message& msg) {
   if (msg.routing_id() == MSG_ROUTING_CONTROL)
     return OnControlMessageReceived(msg);
 
   return router_.RouteMessage(msg);
@@ skipping 147 matching lines @@
 }
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
+#if defined(OS_ANDROID)
+void GpuChannelManager::DidAccessGpu() {
+  last_gpu_access_time_ = base::TimeTicks::Now();
+}
+
+void GpuChannelManager::OnWakeUpGpu() {
+  begin_wake_up_time_ = base::TimeTicks::Now();
+  ScheduleWakeUpGpu();
+}
+
+void GpuChannelManager::ScheduleWakeUpGpu() {
+  base::TimeTicks now = base::TimeTicks::Now();
+  TRACE_EVENT2("gpu", "ImageTransportSurfaceAndroid::ScheduleWakeUp",

[no sievers, 2015/09/23 19:32:33]

nit: ImageTransportSurface->GpuChannelManager

[piman, 2015/09/23 22:32:32]

Done.

+               "idle_time", (now - last_gpu_access_time_).InMilliseconds(),
+               "keep_awake_time", (now - begin_wake_up_time_).InMilliseconds());
+  if (now - last_gpu_access_time_ <
+      base::TimeDelta::FromMilliseconds(kMaxGpuIdleTimeMs))
+    return;
+  if (now - begin_wake_up_time_ >
+      base::TimeDelta::FromMilliseconds(kMaxKeepAliveTimeMs))
+    return;
+
+  DoWakeUpGpu();
+
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, base::Bind(&GpuChannelManager::ScheduleWakeUpGpu,
+                            weak_factory_.GetWeakPtr()),
+      base::TimeDelta::FromMilliseconds(kMaxGpuIdleTimeMs));
+}
+
+void GpuChannelManager::DoWakeUpGpu() {
+  const GpuCommandBufferStub* stub = nullptr;
+  for (const auto& kv : gpu_channels_) {
+    const GpuChannel* channel = kv.second;
+    stub = channel->GetOneStub();
+    if (stub) {
+      DCHECK(stub->decoder());
+      break;
+    }
+  }
+  if (!stub || !stub->decoder()->MakeCurrent())
+    return;
+  glFinish();
+  DidAccessGpu();
+}
+#endif
+
 }  // namespace content