content/browser/gpu/gpu_process_host_ui_shim.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/debug/trace_event.h"
  11 #include "base/id_map.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "content/browser/gpu/compositor_util.h"
  15 #include "content/browser/gpu/gpu_data_manager_impl.h"
  16 #include "content/browser/gpu/gpu_process_host.h"
  17 #include "content/browser/gpu/gpu_surface_tracker.h"
  18 #include "content/browser/renderer_host/render_process_host_impl.h"
  19 #include "content/browser/renderer_host/render_view_host_impl.h"
  20 #include "content/browser/renderer_host/render_widget_helper.h"
  21 #include "content/browser/renderer_host/render_widget_host_view_base.h"
  22 #include "content/common/gpu/gpu_messages.h"
  23 #include "content/public/browser/browser_thread.h"
  24
  25 #if defined(OS_MACOSX)
  26 #include "content/browser/compositor/browser_compositor_view_mac.h"
  27 #endif
  28
  29 #if defined(USE_OZONE)
  30 #include "ui/ozone/public/gpu_platform_support_host.h"
  31 #include "ui/ozone/public/ozone_platform.h"
  32 #endif
  33
  34 namespace content {
  35
  36 namespace {
  37
  38 // One of the linux specific headers defines this as a macro.
  39 #ifdef DestroyAll
  40 #undef DestroyAll
  41 #endif
  42
  43 base::LazyInstance<IDMap<GpuProcessHostUIShim> > g_hosts_by_id =
  44     LAZY_INSTANCE_INITIALIZER;
  45
  46 void SendOnIOThreadTask(int host_id, IPC::Message* msg) {
  47   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
  48   if (host)
  49     host->Send(msg);
  50   else
  51     delete msg;
  52 }
  53
  54 class ScopedSendOnIOThread {
  55  public:
  56   ScopedSendOnIOThread(int host_id, IPC::Message* msg)
  57       : host_id_(host_id),
  58         msg_(msg),
  59         cancelled_(false) {
  60   }
  61
  62   ~ScopedSendOnIOThread() {
  63     if (!cancelled_) {
  64       BrowserThread::PostTask(BrowserThread::IO,
  65                               FROM_HERE,
  66                               base::Bind(&SendOnIOThreadTask,
  67                                          host_id_,
  68                                          msg_.release()));
  69     }
  70   }
  71
  72   void Cancel() { cancelled_ = true; }
  73
  74  private:
  75   int host_id_;
  76   scoped_ptr<IPC::Message> msg_;
  77   bool cancelled_;
  78 };
  79
  80 RenderWidgetHostViewBase* GetRenderWidgetHostViewFromSurfaceID(
  81     int surface_id) {
  82   int render_process_id = 0;
  83   int render_widget_id = 0;
  84   if (!GpuSurfaceTracker::Get()->GetRenderWidgetIDForSurface(
  85         surface_id, &render_process_id, &render_widget_id))
  86     return NULL;
  87
  88   RenderWidgetHost* host =
  89       RenderWidgetHost::FromID(render_process_id, render_widget_id);
  90   return host ? static_cast<RenderWidgetHostViewBase*>(host->GetView()) : NULL;
  91 }
  92
  93 }  // namespace
  94
  95 void RouteToGpuProcessHostUIShimTask(int host_id, const IPC::Message& msg) {
  96   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(host_id);
  97   if (ui_shim)
  98     ui_shim->OnMessageReceived(msg);
  99 }
 100
 101 GpuProcessHostUIShim::GpuProcessHostUIShim(int host_id)
 102     : host_id_(host_id) {
 103   g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
 104 #if defined(USE_OZONE)
 105   ui::OzonePlatform::GetInstance()
 106       ->GetGpuPlatformSupportHost()
 107       ->OnChannelEstablished(host_id, this);
 108 #endif
 109 }
 110
 111 // static
 112 GpuProcessHostUIShim* GpuProcessHostUIShim::Create(int host_id) {
 113   DCHECK(!FromID(host_id));
 114   return new GpuProcessHostUIShim(host_id);
 115 }
 116
 117 // static
 118 void GpuProcessHostUIShim::Destroy(int host_id, const std::string& message) {
 119   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 120
 121   GpuDataManagerImpl::GetInstance()->AddLogMessage(
 122       logging::LOG_ERROR, "GpuProcessHostUIShim",
 123       message);
 124
 125 #if defined(USE_OZONE)
 126   ui::OzonePlatform::GetInstance()
 127       ->GetGpuPlatformSupportHost()
 128       ->OnChannelDestroyed(host_id);
 129 #endif
 130
 131   delete FromID(host_id);
 132 }
 133
 134 // static
 135 void GpuProcessHostUIShim::DestroyAll() {
 136   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 137   while (!g_hosts_by_id.Pointer()->IsEmpty()) {
 138     IDMap<GpuProcessHostUIShim>::iterator it(g_hosts_by_id.Pointer());
 139     delete it.GetCurrentValue();
 140   }
 141 }
 142
 143 // static
 144 GpuProcessHostUIShim* GpuProcessHostUIShim::FromID(int host_id) {
 145   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 146   return g_hosts_by_id.Pointer()->Lookup(host_id);
 147 }
 148
 149 // static
 150 GpuProcessHostUIShim* GpuProcessHostUIShim::GetOneInstance() {
 151   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 152   if (g_hosts_by_id.Pointer()->IsEmpty())
 153     return NULL;
 154   IDMap<GpuProcessHostUIShim>::iterator it(g_hosts_by_id.Pointer());
 155   return it.GetCurrentValue();
 156 }
 157
 158 bool GpuProcessHostUIShim::Send(IPC::Message* msg) {
 159   DCHECK(CalledOnValidThread());
 160   return BrowserThread::PostTask(BrowserThread::IO,
 161                                  FROM_HERE,
 162                                  base::Bind(&SendOnIOThreadTask,
 163                                             host_id_,
 164                                             msg));
 165 }
 166
 167 bool GpuProcessHostUIShim::OnMessageReceived(const IPC::Message& message) {
 168   DCHECK(CalledOnValidThread());
 169
 170 #if defined(USE_OZONE)
 171   if (ui::OzonePlatform::GetInstance()
 172           ->GetGpuPlatformSupportHost()
 173           ->OnMessageReceived(message))
 174     return true;
 175 #endif
 176
 177   if (message.routing_id() != MSG_ROUTING_CONTROL)
 178     return false;
 179
 180   return OnControlMessageReceived(message);
 181 }
 182
 183 void GpuProcessHostUIShim::SimulateRemoveAllContext() {
 184   Send(new GpuMsg_Clean());
 185 }
 186
 187 void GpuProcessHostUIShim::SimulateCrash() {
 188   Send(new GpuMsg_Crash());
 189 }
 190
 191 void GpuProcessHostUIShim::SimulateHang() {
 192   Send(new GpuMsg_Hang());
 193 }
 194
 195 GpuProcessHostUIShim::~GpuProcessHostUIShim() {
 196   DCHECK(CalledOnValidThread());
 197   g_hosts_by_id.Pointer()->Remove(host_id_);
 198 }
 199
 200 bool GpuProcessHostUIShim::OnControlMessageReceived(
 201     const IPC::Message& message) {
 202   DCHECK(CalledOnValidThread());
 203
 204   IPC_BEGIN_MESSAGE_MAP(GpuProcessHostUIShim, message)
 205     IPC_MESSAGE_HANDLER(GpuHostMsg_OnLogMessage,
 206                         OnLogMessage)
 207
 208     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceInitialized,
 209                         OnAcceleratedSurfaceInitialized)
 210     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
 211                         OnAcceleratedSurfaceBuffersSwapped)
 212     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfacePostSubBuffer,
 213                         OnAcceleratedSurfacePostSubBuffer)
 214     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceSuspend,
 215                         OnAcceleratedSurfaceSuspend)
 216     IPC_MESSAGE_HANDLER(GpuHostMsg_GraphicsInfoCollected,
 217                         OnGraphicsInfoCollected)
 218     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceRelease,
 219                         OnAcceleratedSurfaceRelease)
 220     IPC_MESSAGE_HANDLER(GpuHostMsg_VideoMemoryUsageStats,
 221                         OnVideoMemoryUsageStatsReceived);
 222     IPC_MESSAGE_HANDLER(GpuHostMsg_FrameDrawn, OnFrameDrawn)
 223
 224     IPC_MESSAGE_UNHANDLED_ERROR()
 225   IPC_END_MESSAGE_MAP()
 226
 227   return true;
 228 }
 229
 230 void GpuProcessHostUIShim::OnLogMessage(
 231     int level,
 232     const std::string& header,
 233     const std::string& message) {
 234   GpuDataManagerImpl::GetInstance()->AddLogMessage(
 235       level, header, message);
 236 }
 237
 238 void GpuProcessHostUIShim::OnGraphicsInfoCollected(
 239     const gpu::GPUInfo& gpu_info) {
 240   // OnGraphicsInfoCollected is sent back after the GPU process successfully
 241   // initializes GL.
 242   TRACE_EVENT0("test_gpu", "OnGraphicsInfoCollected");
 243
 244   GpuDataManagerImpl::GetInstance()->UpdateGpuInfo(gpu_info);
 245 }
 246
 247 void GpuProcessHostUIShim::OnAcceleratedSurfaceInitialized(int32 surface_id,
 248                                                            int32 route_id) {
 249   RenderWidgetHostViewBase* view =
 250       GetRenderWidgetHostViewFromSurfaceID(surface_id);
 251   if (!view)
 252     return;
 253   view->AcceleratedSurfaceInitialized(host_id_, route_id);
 254 }
 255
 256 void GpuProcessHostUIShim::OnAcceleratedSurfaceBuffersSwapped(
 257     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
 258   TRACE_EVENT0("renderer",
 259       "GpuProcessHostUIShim::OnAcceleratedSurfaceBuffersSwapped");
 260   if (!ui::LatencyInfo::Verify(params.latency_info,
 261                                "GpuHostMsg_AcceleratedSurfaceBuffersSwapped"))
 262     return;
 263
 264 #if defined(OS_MACOSX)
 265   // On Mac with delegated rendering, accelerated surfaces are not necessarily
 266   // associated with a RenderWidgetHostViewBase.
 267   if (IsDelegatedRendererEnabled()) {
 268     gfx::AcceleratedWidget native_widget =
 269         content::GpuSurfaceTracker::Get()->AcquireNativeWidget(
 270             params.surface_id);
 271     BrowserCompositorViewMac::GotAcceleratedFrame(
 272         native_widget, params.surface_handle, params.surface_id,
 273         params.latency_info, params.size, params.scale_factor,
 274         host_id_, params.route_id);
 275     return;
 276   }
 277 #endif
 278
 279   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
 280   ack_params.mailbox = params.mailbox;
 281   ack_params.sync_point = 0;
 282   ScopedSendOnIOThread delayed_send(
 283       host_id_,
 284       new AcceleratedSurfaceMsg_BufferPresented(params.route_id,
 285                                                 ack_params));
 286
 287   RenderWidgetHostViewBase* view = GetRenderWidgetHostViewFromSurfaceID(
 288       params.surface_id);
 289   if (!view)
 290     return;
 291
 292   delayed_send.Cancel();
 293
 294   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params view_params = params;
 295
 296   RenderWidgetHostImpl* impl =
 297       RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
 298   for (size_t i = 0; i < view_params.latency_info.size(); i++)
 299     impl->AddLatencyInfoComponentIds(&view_params.latency_info[i]);
 300
 301   // View must send ACK message after next composite.
 302   view->AcceleratedSurfaceBuffersSwapped(view_params, host_id_);
 303   view->DidReceiveRendererFrame();
 304 }
 305
 306 void GpuProcessHostUIShim::OnFrameDrawn(
 307     const std::vector<ui::LatencyInfo>& latency_info) {
 308   if (!ui::LatencyInfo::Verify(latency_info,
 309                                "GpuProcessHostUIShim::OnFrameDrawn"))
 310     return;
 311   RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
 312 }
 313
 314 void GpuProcessHostUIShim::OnAcceleratedSurfacePostSubBuffer(
 315     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params) {
 316   TRACE_EVENT0("renderer",
 317       "GpuProcessHostUIShim::OnAcceleratedSurfacePostSubBuffer");
 318   if (!ui::LatencyInfo::Verify(params.latency_info,
 319                                "GpuHostMsg_AcceleratedSurfacePostSubBuffer"))
 320     return;
 321   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
 322   ack_params.mailbox = params.mailbox;
 323   ack_params.sync_point = 0;
 324   ScopedSendOnIOThread delayed_send(
 325       host_id_,
 326       new AcceleratedSurfaceMsg_BufferPresented(params.route_id,
 327                                                 ack_params));
 328
 329   RenderWidgetHostViewBase* view =
 330       GetRenderWidgetHostViewFromSurfaceID(params.surface_id);
 331   if (!view)
 332     return;
 333
 334   delayed_send.Cancel();
 335
 336   GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params view_params = params;
 337
 338   RenderWidgetHostImpl* impl =
 339       RenderWidgetHostImpl::From(view->GetRenderWidgetHost());
 340   for (size_t i = 0; i < view_params.latency_info.size(); i++)
 341     impl->AddLatencyInfoComponentIds(&view_params.latency_info[i]);
 342
 343   // View must send ACK message after next composite.
 344   view->AcceleratedSurfacePostSubBuffer(view_params, host_id_);
 345   view->DidReceiveRendererFrame();
 346 }
 347
 348 void GpuProcessHostUIShim::OnAcceleratedSurfaceSuspend(int32 surface_id) {
 349   TRACE_EVENT0("renderer",
 350       "GpuProcessHostUIShim::OnAcceleratedSurfaceSuspend");
 351
 352   RenderWidgetHostViewBase* view =
 353       GetRenderWidgetHostViewFromSurfaceID(surface_id);
 354   if (!view)
 355     return;
 356
 357   view->AcceleratedSurfaceSuspend();
 358 }
 359
 360 void GpuProcessHostUIShim::OnAcceleratedSurfaceRelease(
 361     const GpuHostMsg_AcceleratedSurfaceRelease_Params& params) {
 362   RenderWidgetHostViewBase* view = GetRenderWidgetHostViewFromSurfaceID(
 363       params.surface_id);
 364   if (!view)
 365     return;
 366   view->AcceleratedSurfaceRelease();
 367 }
 368
 369 void GpuProcessHostUIShim::OnVideoMemoryUsageStatsReceived(
 370     const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
 371   GpuDataManagerImpl::GetInstance()->UpdateVideoMemoryUsageStats(
 372       video_memory_usage_stats);
 373 }
 374
 375 }  // namespace content