src/content/browser/compositor/gpu_process_transport_factory.cc

   1 // Copyright 2014 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/compositor/gpu_process_transport_factory.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/location.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/threading/thread.h"
  15 #include "cc/output/compositor_frame.h"
  16 #include "cc/output/output_surface.h"
  17 #include "cc/surfaces/surface_manager.h"
  18 #include "content/browser/compositor/browser_compositor_output_surface.h"
  19 #include "content/browser/compositor/browser_compositor_output_surface_proxy.h"
  20 #include "content/browser/compositor/gpu_browser_compositor_output_surface.h"
  21 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
  22 #include "content/browser/compositor/onscreen_display_client.h"
  23 #include "content/browser/compositor/reflector_impl.h"
  24 #include "content/browser/compositor/software_browser_compositor_output_surface.h"
  25 #include "content/browser/compositor/surface_display_output_surface.h"
  26 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
  27 #include "content/browser/gpu/compositor_util.h"
  28 #include "content/browser/gpu/gpu_data_manager_impl.h"
  29 #include "content/browser/gpu/gpu_surface_tracker.h"
  30 #include "content/browser/renderer_host/render_widget_host_impl.h"
  31 #include "content/common/gpu/client/context_provider_command_buffer.h"
  32 #include "content/common/gpu/client/gl_helper.h"
  33 #include "content/common/gpu/client/gpu_channel_host.h"
  34 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
  35 #include "content/common/gpu/gpu_process_launch_causes.h"
  36 #include "content/common/host_shared_bitmap_manager.h"
  37 #include "content/public/common/content_switches.h"
  38 #include "gpu/GLES2/gl2extchromium.h"
  39 #include "gpu/command_buffer/client/gles2_interface.h"
  40 #include "gpu/command_buffer/common/mailbox.h"
  41 #include "third_party/khronos/GLES2/gl2.h"
  42 #include "ui/compositor/compositor.h"
  43 #include "ui/compositor/compositor_constants.h"
  44 #include "ui/compositor/compositor_switches.h"
  45 #include "ui/gfx/native_widget_types.h"
  46 #include "ui/gfx/size.h"
  47
  48 #if defined(OS_WIN)
  49 #include "content/browser/compositor/software_output_device_win.h"
  50 #elif defined(USE_OZONE)
  51 #include "content/browser/compositor/overlay_candidate_validator_ozone.h"
  52 #include "content/browser/compositor/software_output_device_ozone.h"
  53 #include "ui/ozone/public/surface_factory_ozone.h"
  54 #elif defined(USE_X11)
  55 #include "content/browser/compositor/software_output_device_x11.h"
  56 #elif defined(OS_MACOSX)
  57 #include "content/browser/compositor/software_output_device_mac.h"
  58 #endif
  59
  60 using cc::ContextProvider;
  61 using gpu::gles2::GLES2Interface;
  62
  63 namespace content {
  64
  65 struct GpuProcessTransportFactory::PerCompositorData {
  66   int surface_id;
  67   scoped_refptr<ReflectorImpl> reflector;
  68   scoped_ptr<OnscreenDisplayClient> display_client;
  69 };
  70
  71 GpuProcessTransportFactory::GpuProcessTransportFactory()
  72     : next_surface_id_namespace_(1u),
  73       callback_factory_(this) {
  74   output_surface_proxy_ = new BrowserCompositorOutputSurfaceProxy(
  75       &output_surface_map_);
  76 #if defined(OS_CHROMEOS)
  77   bool use_thread = !base::CommandLine::ForCurrentProcess()->HasSwitch(
  78       switches::kUIDisableThreadedCompositing);
  79 #else
  80   bool use_thread = false;
  81 #endif
  82   if (use_thread) {
  83     compositor_thread_.reset(new base::Thread("Browser Compositor"));
  84     compositor_thread_->Start();
  85   }
  86   if (UseSurfacesEnabled())
  87     surface_manager_ = make_scoped_ptr(new cc::SurfaceManager);
  88 }
  89
  90 GpuProcessTransportFactory::~GpuProcessTransportFactory() {
  91   DCHECK(per_compositor_data_.empty());
  92
  93   // Make sure the lost context callback doesn't try to run during destruction.
  94   callback_factory_.InvalidateWeakPtrs();
  95 }
  96
  97 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
  98 GpuProcessTransportFactory::CreateOffscreenCommandBufferContext() {
  99   return CreateContextCommon(0);
 100 }
 101
 102 scoped_ptr<cc::SoftwareOutputDevice> CreateSoftwareOutputDevice(
 103     ui::Compositor* compositor) {
 104 #if defined(OS_WIN)
 105   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceWin(
 106       compositor));
 107 #elif defined(USE_OZONE)
 108   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceOzone(
 109       compositor));
 110 #elif defined(USE_X11)
 111   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceX11(
 112       compositor));
 113 #elif defined(OS_MACOSX)
 114   return scoped_ptr<cc::SoftwareOutputDevice>(
 115       new SoftwareOutputDeviceMac(compositor));
 116 #else
 117   NOTREACHED();
 118   return scoped_ptr<cc::SoftwareOutputDevice>();
 119 #endif
 120 }
 121
 122 scoped_ptr<cc::OverlayCandidateValidator> CreateOverlayCandidateValidator(
 123     gfx::AcceleratedWidget widget) {
 124 #if defined(USE_OZONE)
 125   ui::OverlayCandidatesOzone* overlay_candidates =
 126       ui::SurfaceFactoryOzone::GetInstance()->GetOverlayCandidates(widget);
 127   if (overlay_candidates &&
 128       base::CommandLine::ForCurrentProcess()->HasSwitch(
 129           switches::kEnableHardwareOverlays)) {
 130     return scoped_ptr<cc::OverlayCandidateValidator>(
 131         new OverlayCandidateValidatorOzone(widget, overlay_candidates));
 132   }
 133 #endif
 134   return scoped_ptr<cc::OverlayCandidateValidator>();
 135 }
 136
 137 scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
 138     ui::Compositor* compositor, bool software_fallback) {
 139   PerCompositorData* data = per_compositor_data_[compositor];
 140   if (!data)
 141     data = CreatePerCompositorData(compositor);
 142
 143   bool create_software_renderer = software_fallback;
 144 #if defined(OS_CHROMEOS)
 145   // Software fallback does not happen on Chrome OS.
 146   create_software_renderer = false;
 147 #elif defined(OS_WIN)
 148   if (::GetProp(compositor->widget(), kForceSoftwareCompositor)) {
 149     if (::RemoveProp(compositor->widget(), kForceSoftwareCompositor))
 150       create_software_renderer = true;
 151   }
 152 #endif
 153
 154   scoped_refptr<ContextProviderCommandBuffer> context_provider;
 155
 156   if (!create_software_renderer) {
 157     context_provider = ContextProviderCommandBuffer::Create(
 158         GpuProcessTransportFactory::CreateContextCommon(data->surface_id),
 159         "Compositor");
 160   }
 161
 162   UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor",
 163                         !!context_provider.get());
 164
 165   if (context_provider.get()) {
 166     scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
 167         GetCompositorMessageLoop();
 168     if (!compositor_thread_task_runner.get())
 169       compositor_thread_task_runner = base::MessageLoopProxy::current();
 170
 171     // Here we know the GpuProcessHost has been set up, because we created a
 172     // context.
 173     output_surface_proxy_->ConnectToGpuProcessHost(
 174         compositor_thread_task_runner.get());
 175   }
 176
 177   if (UseSurfacesEnabled()) {
 178     // This gets a bit confusing. Here we have a ContextProvider configured to
 179     // render directly to this widget. We need to make an OnscreenDisplayClient
 180     // associated with this context, then return a SurfaceDisplayOutputSurface
 181     // set up to draw to the display's surface.
 182     cc::SurfaceManager* manager = surface_manager_.get();
 183     scoped_ptr<cc::OutputSurface> display_surface;
 184     if (!context_provider.get()) {
 185       display_surface =
 186           make_scoped_ptr(new SoftwareBrowserCompositorOutputSurface(
 187               output_surface_proxy_,
 188               CreateSoftwareOutputDevice(compositor),
 189               per_compositor_data_[compositor]->surface_id,
 190               &output_surface_map_,
 191               compositor->vsync_manager()));
 192     } else {
 193       display_surface = make_scoped_ptr(new GpuBrowserCompositorOutputSurface(
 194           context_provider,
 195           per_compositor_data_[compositor]->surface_id,
 196           &output_surface_map_,
 197           compositor->vsync_manager(),
 198           CreateOverlayCandidateValidator(compositor->widget())));
 199     }
 200     scoped_ptr<OnscreenDisplayClient> display_client(new OnscreenDisplayClient(
 201         display_surface.Pass(), manager, compositor->task_runner()));
 202
 203     scoped_refptr<cc::ContextProvider> offscreen_context_provider;
 204     if (context_provider.get()) {
 205       offscreen_context_provider = ContextProviderCommandBuffer::Create(
 206           GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
 207           "Offscreen-Compositor");
 208     }
 209     scoped_ptr<SurfaceDisplayOutputSurface> output_surface(
 210         new SurfaceDisplayOutputSurface(manager,
 211           next_surface_id_namespace_++,
 212           offscreen_context_provider));
 213     display_client->set_surface_output_surface(output_surface.get());
 214     output_surface->set_display(display_client->display());
 215     data->display_client = display_client.Pass();
 216     return output_surface.PassAs<cc::OutputSurface>();
 217   }
 218
 219   if (!context_provider.get()) {
 220     if (compositor_thread_.get()) {
 221       LOG(FATAL) << "Failed to create UI context, but can't use software"
 222                  " compositing with browser threaded compositing. Aborting.";
 223     }
 224
 225     scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface(
 226         new SoftwareBrowserCompositorOutputSurface(
 227             output_surface_proxy_,
 228             CreateSoftwareOutputDevice(compositor),
 229             per_compositor_data_[compositor]->surface_id,
 230             &output_surface_map_,
 231             compositor->vsync_manager()));
 232     return surface.PassAs<cc::OutputSurface>();
 233   }
 234
 235   scoped_ptr<BrowserCompositorOutputSurface> surface;
 236 #if defined(USE_OZONE)
 237   if (ui::SurfaceFactoryOzone::GetInstance()->CanShowPrimaryPlaneAsOverlay()) {
 238     surface.reset(new GpuSurfacelessBrowserCompositorOutputSurface(
 239         context_provider,
 240         per_compositor_data_[compositor]->surface_id,
 241         &output_surface_map_,
 242         compositor->vsync_manager(),
 243         CreateOverlayCandidateValidator(compositor->widget()),
 244         GL_RGB8_OES));
 245   }
 246 #endif
 247   if (!surface)
 248     surface.reset(new GpuBrowserCompositorOutputSurface(
 249         context_provider,
 250         per_compositor_data_[compositor]->surface_id,
 251         &output_surface_map_,
 252         compositor->vsync_manager(),
 253         CreateOverlayCandidateValidator(compositor->widget())));
 254
 255   if (data->reflector.get())
 256     data->reflector->ReattachToOutputSurfaceFromMainThread(surface.get());
 257
 258   return surface.PassAs<cc::OutputSurface>();
 259 }
 260
 261 scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
 262     ui::Compositor* source,
 263     ui::Layer* target) {
 264   PerCompositorData* data = per_compositor_data_[source];
 265   DCHECK(data);
 266
 267   data->reflector = new ReflectorImpl(source,
 268                                       target,
 269                                       &output_surface_map_,
 270                                       GetCompositorMessageLoop(),
 271                                       data->surface_id);
 272   return data->reflector;
 273 }
 274
 275 void GpuProcessTransportFactory::RemoveReflector(
 276     scoped_refptr<ui::Reflector> reflector) {
 277   ReflectorImpl* reflector_impl =
 278       static_cast<ReflectorImpl*>(reflector.get());
 279   PerCompositorData* data =
 280       per_compositor_data_[reflector_impl->mirrored_compositor()];
 281   DCHECK(data);
 282   data->reflector->Shutdown();
 283   data->reflector = NULL;
 284 }
 285
 286 void GpuProcessTransportFactory::RemoveCompositor(ui::Compositor* compositor) {
 287   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
 288   if (it == per_compositor_data_.end())
 289     return;
 290   PerCompositorData* data = it->second;
 291   DCHECK(data);
 292   GpuSurfaceTracker::Get()->RemoveSurface(data->surface_id);
 293   delete data;
 294   per_compositor_data_.erase(it);
 295   if (per_compositor_data_.empty()) {
 296     // Destroying the GLHelper may cause some async actions to be cancelled,
 297     // causing things to request a new GLHelper. Due to crbug.com/176091 the
 298     // GLHelper created in this case would be lost/leaked if we just reset()
 299     // on the |gl_helper_| variable directly. So instead we call reset() on a
 300     // local scoped_ptr.
 301     scoped_ptr<GLHelper> helper = gl_helper_.Pass();
 302
 303     // If there are any observer left at this point, make sure they clean up
 304     // before we destroy the GLHelper.
 305     FOR_EACH_OBSERVER(
 306         ImageTransportFactoryObserver, observer_list_, OnLostResources());
 307
 308     helper.reset();
 309     DCHECK(!gl_helper_) << "Destroying the GLHelper should not cause a new "
 310                            "GLHelper to be created.";
 311   }
 312 }
 313
 314 bool GpuProcessTransportFactory::DoesCreateTestContexts() { return false; }
 315
 316 cc::SharedBitmapManager* GpuProcessTransportFactory::GetSharedBitmapManager() {
 317   return HostSharedBitmapManager::current();
 318 }
 319
 320 ui::ContextFactory* GpuProcessTransportFactory::GetContextFactory() {
 321   return this;
 322 }
 323
 324 base::MessageLoopProxy* GpuProcessTransportFactory::GetCompositorMessageLoop() {
 325   if (!compositor_thread_)
 326     return NULL;
 327   return compositor_thread_->message_loop_proxy().get();
 328 }
 329
 330 gfx::GLSurfaceHandle GpuProcessTransportFactory::GetSharedSurfaceHandle() {
 331   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
 332       gfx::kNullPluginWindow, gfx::TEXTURE_TRANSPORT);
 333   handle.parent_client_id =
 334       BrowserGpuChannelHostFactory::instance()->GetGpuChannelId();
 335   return handle;
 336 }
 337
 338 scoped_ptr<cc::SurfaceIdAllocator>
 339 GpuProcessTransportFactory::CreateSurfaceIdAllocator() {
 340   return make_scoped_ptr(
 341       new cc::SurfaceIdAllocator(next_surface_id_namespace_++));
 342 }
 343
 344 cc::SurfaceManager* GpuProcessTransportFactory::GetSurfaceManager() {
 345   return surface_manager_.get();
 346 }
 347
 348 GLHelper* GpuProcessTransportFactory::GetGLHelper() {
 349   if (!gl_helper_ && !per_compositor_data_.empty()) {
 350     scoped_refptr<cc::ContextProvider> provider =
 351         SharedMainThreadContextProvider();
 352     if (provider.get())
 353       gl_helper_.reset(new GLHelper(provider->ContextGL(),
 354                                     provider->ContextSupport()));
 355   }
 356   return gl_helper_.get();
 357 }
 358
 359 void GpuProcessTransportFactory::AddObserver(
 360     ImageTransportFactoryObserver* observer) {
 361   observer_list_.AddObserver(observer);
 362 }
 363
 364 void GpuProcessTransportFactory::RemoveObserver(
 365     ImageTransportFactoryObserver* observer) {
 366   observer_list_.RemoveObserver(observer);
 367 }
 368
 369 #if defined(OS_MACOSX)
 370 void GpuProcessTransportFactory::OnSurfaceDisplayed(int surface_id) {
 371   BrowserCompositorOutputSurface* surface = output_surface_map_.Lookup(
 372       surface_id);
 373   if (surface)
 374     surface->OnSurfaceDisplayed();
 375 }
 376 #endif
 377
 378 scoped_refptr<cc::ContextProvider>
 379 GpuProcessTransportFactory::SharedMainThreadContextProvider() {
 380   if (shared_main_thread_contexts_.get())
 381     return shared_main_thread_contexts_;
 382
 383   // In threaded compositing mode, we have to create our own context for the
 384   // main thread since the compositor's context will be bound to the
 385   // compositor thread. When not in threaded mode, we still need a separate
 386   // context so that skia and gl_helper don't step on each other.
 387   shared_main_thread_contexts_ = ContextProviderCommandBuffer::Create(
 388       GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
 389       "Offscreen-MainThread");
 390
 391   if (shared_main_thread_contexts_.get()) {
 392     shared_main_thread_contexts_->SetLostContextCallback(
 393         base::Bind(&GpuProcessTransportFactory::
 394                         OnLostMainThreadSharedContextInsideCallback,
 395                    callback_factory_.GetWeakPtr()));
 396     if (!shared_main_thread_contexts_->BindToCurrentThread())
 397       shared_main_thread_contexts_ = NULL;
 398   }
 399   return shared_main_thread_contexts_;
 400 }
 401
 402 GpuProcessTransportFactory::PerCompositorData*
 403 GpuProcessTransportFactory::CreatePerCompositorData(
 404     ui::Compositor* compositor) {
 405   DCHECK(!per_compositor_data_[compositor]);
 406
 407   gfx::AcceleratedWidget widget = compositor->widget();
 408   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 409
 410   PerCompositorData* data = new PerCompositorData;
 411   data->surface_id = tracker->AddSurfaceForNativeWidget(widget);
 412   tracker->SetSurfaceHandle(
 413       data->surface_id,
 414       gfx::GLSurfaceHandle(widget, gfx::NATIVE_DIRECT));
 415
 416   per_compositor_data_[compositor] = data;
 417
 418   return data;
 419 }
 420
 421 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 422 GpuProcessTransportFactory::CreateContextCommon(int surface_id) {
 423   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
 424     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
 425   blink::WebGraphicsContext3D::Attributes attrs;
 426   attrs.shareResources = true;
 427   attrs.depth = false;
 428   attrs.stencil = false;
 429   attrs.antialias = false;
 430   attrs.noAutomaticFlushes = true;
 431   bool lose_context_when_out_of_memory = true;
 432   CauseForGpuLaunch cause =
 433       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
 434   scoped_refptr<GpuChannelHost> gpu_channel_host(
 435       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
 436   if (!gpu_channel_host.get()) {
 437     LOG(ERROR) << "Failed to establish GPU channel.";
 438     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
 439   }
 440   GURL url("chrome://gpu/GpuProcessTransportFactory::CreateContextCommon");
 441   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
 442       new WebGraphicsContext3DCommandBufferImpl(
 443           surface_id,
 444           url,
 445           gpu_channel_host.get(),
 446           attrs,
 447           lose_context_when_out_of_memory,
 448           WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
 449           NULL));
 450   return context.Pass();
 451 }
 452
 453 void GpuProcessTransportFactory::OnLostMainThreadSharedContextInsideCallback() {
 454   base::MessageLoop::current()->PostTask(
 455       FROM_HERE,
 456       base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
 457                  callback_factory_.GetWeakPtr()));
 458 }
 459
 460 void GpuProcessTransportFactory::OnLostMainThreadSharedContext() {
 461   LOG(ERROR) << "Lost UI shared context.";
 462
 463   // Keep old resources around while we call the observers, but ensure that
 464   // new resources are created if needed.
 465   // Kill shared contexts for both threads in tandem so they are always in
 466   // the same share group.
 467   scoped_refptr<cc::ContextProvider> lost_shared_main_thread_contexts =
 468       shared_main_thread_contexts_;
 469   shared_main_thread_contexts_  = NULL;
 470
 471   scoped_ptr<GLHelper> lost_gl_helper = gl_helper_.Pass();
 472
 473   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
 474                     observer_list_,
 475                     OnLostResources());
 476
 477   // Kill things that use the shared context before killing the shared context.
 478   lost_gl_helper.reset();
 479   lost_shared_main_thread_contexts  = NULL;
 480 }
 481
 482 }  // namespace content