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