Created multi-process-friendly PowerMonitor interface.

content/common/gpu/client/gpu_channel_host.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/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/power_monitor/power_monitor.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/common/power_monitor_message_broadcaster.h"
 #include "googleurl/src/gurl.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "ipc/ipc_sync_message_filter.h"
 
 #if defined(OS_WIN)
 #include "content/public/common/sandbox_init.h"
 #endif
 
 using base::AutoLock;
 using base::MessageLoopProxy;
@@ skipping 18 matching lines @@
   return host;
 }
 
 GpuChannelHost::GpuChannelHost(GpuChannelHostFactory* factory,
                                int gpu_host_id,
                                int client_id,
                                const gpu::GPUInfo& gpu_info)
     : factory_(factory),
       client_id_(client_id),
       gpu_host_id_(gpu_host_id),
-      gpu_info_(gpu_info) {
+      gpu_info_(gpu_info),
+      power_monitor_broadcaster_(new PowerMonitorMessageBroadcaster(this)) {
   next_transfer_buffer_id_.GetNext();
+
+  base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
+  if (power_monitor)
+    power_monitor->AddObserver(power_monitor_broadcaster_.get());

[Ken Russell (switch to Gerrit), 2013/06/27 13:08:23]

As I mentioned in earlier review, I think the way this currently works at all is
that GpuChannelHost is used both in the browser and renderer processes to talk
to the GPU process. You really only want to hook up the
PowerMonitorMessageBroadcaster in the browser process, over the single channel
that it uses to talk to the GPU process. I think a more appropriate place for
this setup would be after the call to GpuChannelHost::Create in
BrowserGpuChannelHostFactory::EstablishGpuChannelSync. That way the broadcaster
wouldn't have to be contained in the GpuChannelHost, either.

(Looking more deeply, I can't see where a GpuChannelHost is instantiated in the
browser process -- it looks to me like
BrowserGpuChannelHostFactory::EstablishGpuChannelSync is not called.)

[bajones, 2013/07/01 20:21:58]

It actually appears that BrowserGpuChannelHostFactory is hardly used by the
browser process. Also, rather than a GpuChannelHost the browser process
primarily communicates through the GpuProcessHost, which is established with a
PostTask in BrowserMainLoop
(https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/br...).

I've moved the PowerMonitorBroadcaster onto the GpuProcessHost as a result. Not
sure if there are further concerns regarding it's location.

 }
 
 void GpuChannelHost::Connect(const IPC::ChannelHandle& channel_handle) {
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   channel_.reset(new IPC::SyncChannel(channel_handle,
                                       IPC::Channel::MODE_CLIENT,
                                       NULL,
                                       io_loop.get(),
@@ skipping 329 matching lines @@
   AutoLock lock(lock_);
   DCHECK_LE(names.size(), requested_mailboxes_);
   requested_mailboxes_ -= names.size();
   mailbox_name_pool_.insert(mailbox_name_pool_.end(),
                             names.begin(),
                             names.end());
 }
 
 
 }  // namespace content