Support dynamic switching between integrated and discrete GPUs on Mac OS X.

content/common/gpu/gpu_channel.cc

 // Copyright (c) 2011 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 19 matching lines @@
                        int renderer_id,
                        bool software)
     : gpu_channel_manager_(gpu_channel_manager),
       renderer_id_(renderer_id),
       renderer_process_(base::kNullProcessHandle),
       renderer_pid_(base::kNullProcessId),
       share_group_(new gfx::GLShareGroup),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
+      num_contexts_preferring_discrete_gpu_(0),
       task_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(gpu_channel_manager);
   DCHECK(renderer_id);
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
   disallowed_features_.driver_bug_workarounds =
       command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds);
 }
@@ skipping 110 matching lines @@
 
 void GpuChannel::CreateViewCommandBuffer(
     gfx::PluginWindowHandle window,
     int32 render_view_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32* route_id) {
   *route_id = MSG_ROUTING_NONE;
   content::GetContentClient()->SetActiveURL(init_params.active_url);
 
 #if defined(ENABLE_GPU)
+  WillCreateCommandBuffer(init_params.gpu_preference);
+
   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 
   *route_id = GenerateRouteID();
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this,
       share_group,
       window,
       gfx::Size(),
       disallowed_features_,
       init_params.allowed_extensions,
       init_params.attribs,
+      init_params.gpu_preference,
       *route_id,
       renderer_id_,
       render_view_id,
       watchdog_,
       software_));
   router_.AddRoute(*route_id, stub.get());
   stubs_.AddWithID(stub.release(), *route_id);
 #endif  // ENABLE_GPU
 }
 
@@ skipping 15 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_Initialize, OnInitialize)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_CreateOffscreenCommandBuffer,
                                     OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_DestroyCommandBuffer,
                                     OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateTransportTexture,
         OnCreateTransportTexture)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_Echo, OnEcho);
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_WillGpuSwitchOccur,
+                                    OnWillGpuSwitchOccur)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
 void GpuChannel::HandleMessage() {
   handle_messages_scheduled_ = false;
   if (!IsScheduled())
       return;
@@ skipping 38 matching lines @@
 }
 
 void GpuChannel::AddRoute(int32 route_id, IPC::Channel::Listener* listener) {
   router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
+bool GpuChannel::ShouldPreferDiscreteGpu() const {
+  return num_contexts_preferring_discrete_gpu_ > 0;
+}
+
 void GpuChannel::OnInitialize(base::ProcessHandle renderer_process) {
   // Initialize should only happen once.
   DCHECK(!renderer_process_);
 
   // Verify that the renderer has passed its own process handle.
   if (base::GetProcId(renderer_process) == renderer_pid_)
     renderer_process_ = renderer_process;
 }
 
 void GpuChannel::OnCreateOffscreenCommandBuffer(
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     IPC::Message* reply_message) {
   int32 route_id = MSG_ROUTING_NONE;
 
   content::GetContentClient()->SetActiveURL(init_params.active_url);
 #if defined(ENABLE_GPU)
+  WillCreateCommandBuffer(init_params.gpu_preference);
+
   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 
   route_id = GenerateRouteID();
 
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this,
       share_group,
       gfx::kNullPluginWindow,
       size,
       disallowed_features_,
       init_params.allowed_extensions,
       init_params.attribs,
+      init_params.gpu_preference,
       route_id,
       0, 0, watchdog_,
       software_));
   router_.AddRoute(route_id, stub.get());
   stubs_.AddWithID(stub.release(), route_id);
   TRACE_EVENT1("gpu", "GpuChannel::OnCreateOffscreenCommandBuffer",
                "route_id", route_id);
 #endif
 
   GpuChannelMsg_CreateOffscreenCommandBuffer::WriteReplyParams(
       reply_message,
       route_id);
   Send(reply_message);
 }
 
 void GpuChannel::OnDestroyCommandBuffer(int32 route_id,
                                         IPC::Message* reply_message) {
 #if defined(ENABLE_GPU)
   TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
                "route_id", route_id);
   if (router_.ResolveRoute(route_id)) {
     GpuCommandBufferStub* stub = stubs_.Lookup(route_id);
     bool need_reschedule = (stub && !stub->IsScheduled());
+    gfx::GpuPreference gpu_preference =
+        stub ? stub->gpu_preference() : gfx::PreferIntegratedGpu;
     router_.RemoveRoute(route_id);
     stubs_.Remove(route_id);
     // In case the renderer is currently blocked waiting for a sync reply from
     // the stub, we need to make sure to reschedule the GpuChannel here.
     if (need_reschedule)
       OnScheduled();
+    DidDestroyCommandBuffer(gpu_preference);
   }
 #endif
 
   if (reply_message)
     Send(reply_message);
 }
 
 void GpuChannel::OnCreateTransportTexture(int32 context_route_id,
                                           int32 host_id) {
  #if defined(ENABLE_GPU)
@@ skipping 10 matching lines @@
        host_id, route_id);
    Send(msg);
  #endif
 }
 
 void GpuChannel::OnEcho(const IPC::Message& message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnEcho");
   Send(new IPC::Message(message));
 }
 
+void GpuChannel::OnWillGpuSwitchOccur(bool is_creating_context,
+                                      gfx::GpuPreference gpu_preference,
+                                      IPC::Message* reply_message) {
+  TRACE_EVENT0("gpu", "GpuChannel::OnWillGpuSwitchOccur");
+
+  bool will_switch_occur = false;
+
+  if (gpu_preference == gfx::PreferDiscreteGpu &&
+      gfx::GLContext::SupportsDualGpus()) {
+    if (is_creating_context) {
+      will_switch_occur = !num_contexts_preferring_discrete_gpu_;
+    } else {
+      will_switch_occur = (num_contexts_preferring_discrete_gpu_ == 1);
+    }
+  }
+
+  GpuChannelMsg_WillGpuSwitchOccur::WriteReplyParams(
+      reply_message,
+      will_switch_occur);
+  Send(reply_message);
+}
+
+void GpuChannel::OnCloseChannel() {
+  gpu_channel_manager_->RemoveChannel(renderer_id_);
+  // At this point "this" is deleted!
+}
+
 bool GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
                       base::WaitableEvent* shutdown_event) {
   // Check whether we're already initialized.
   if (channel_.get())
     return true;
 
   // Map renderer ID to a (single) channel to that process.
   std::string channel_name = GetChannelName();
   channel_.reset(new IPC::SyncChannel(
       channel_name,
       IPC::Channel::MODE_SERVER,
       this,
       io_message_loop,
       false,
       shutdown_event));
 
   return true;
 }
 
+void GpuChannel::WillCreateCommandBuffer(gfx::GpuPreference gpu_preference) {
+  if (gpu_preference == gfx::PreferDiscreteGpu)
+    ++num_contexts_preferring_discrete_gpu_;
+}
+
+void GpuChannel::DidDestroyCommandBuffer(gfx::GpuPreference gpu_preference) {
+  if (gpu_preference == gfx::PreferDiscreteGpu)
+    --num_contexts_preferring_discrete_gpu_;

[stuartmorgan, 2011/10/12 07:13:24]

Is it worth DCHECKING here that it's not negative?

[Ken Russell (switch to Gerrit), 2011/10/12 22:39:42]

Sure. Added.

+}
+
 std::string GpuChannel::GetChannelName() {
   return StringPrintf("%d.r%d.gpu", base::GetCurrentProcId(), renderer_id_);
 }
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
   if (!channel_.get()) {
     NOTREACHED();
     return -1;
   }
   return channel_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX)