ui/compositor/compositor.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 "ui/compositor/compositor.h"
   6
   7 #include <algorithm>
   8 #include <deque>
   9
  10 #include "base/bind.h"
  11 #include "base/command_line.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/sys_info.h"
  16 #include "base/trace_event/trace_event.h"
  17 #include "cc/base/latency_info_swap_promise.h"
  18 #include "cc/base/switches.h"
  19 #include "cc/input/input_handler.h"
  20 #include "cc/layers/layer.h"
  21 #include "cc/output/begin_frame_args.h"
  22 #include "cc/output/context_provider.h"
  23 #include "cc/scheduler/begin_frame_source.h"
  24 #include "cc/surfaces/surface_id_allocator.h"
  25 #include "cc/trees/layer_tree_host.h"
  26 #include "third_party/skia/include/core/SkBitmap.h"
  27 #include "ui/compositor/compositor_observer.h"
  28 #include "ui/compositor/compositor_switches.h"
  29 #include "ui/compositor/compositor_vsync_manager.h"
  30 #include "ui/compositor/dip_util.h"
  31 #include "ui/compositor/layer.h"
  32 #include "ui/compositor/layer_animator_collection.h"
  33 #include "ui/gfx/frame_time.h"
  34 #include "ui/gl/gl_context.h"
  35 #include "ui/gl/gl_switches.h"
  36
  37 namespace {
  38
  39 const double kDefaultRefreshRate = 60.0;
  40 const double kTestRefreshRate = 200.0;
  41
  42 const int kCompositorLockTimeoutMs = 67;
  43
  44 }  // namespace
  45
  46 namespace ui {
  47
  48 CompositorLock::CompositorLock(Compositor* compositor)
  49     : compositor_(compositor) {
  50   compositor_->task_runner_->PostDelayedTask(
  51       FROM_HERE,
  52       base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
  53       base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
  54 }
  55
  56 CompositorLock::~CompositorLock() {
  57   CancelLock();
  58 }
  59
  60 void CompositorLock::CancelLock() {
  61   if (!compositor_)
  62     return;
  63   compositor_->UnlockCompositor();
  64   compositor_ = NULL;
  65 }
  66
  67 Compositor::Compositor(gfx::AcceleratedWidget widget,
  68                        ui::ContextFactory* context_factory,
  69                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
  70     : context_factory_(context_factory),
  71       root_layer_(NULL),
  72       widget_(widget),
  73       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
  74       compositor_thread_loop_(context_factory->GetCompositorMessageLoop()),
  75       task_runner_(task_runner),
  76       vsync_manager_(new CompositorVSyncManager()),
  77       device_scale_factor_(0.0f),
  78       last_started_frame_(0),
  79       last_ended_frame_(0),
  80       num_failed_recreate_attempts_(0),
  81       disable_schedule_composite_(false),
  82       compositor_lock_(NULL),
  83       layer_animator_collection_(this),
  84       weak_ptr_factory_(this) {
  85   root_web_layer_ = cc::Layer::Create();
  86
  87   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  88
  89   cc::LayerTreeSettings settings;
  90   // When impl-side painting is enabled, this will ensure PictureLayers always
  91   // can have LCD text, to match the previous behaviour with ContentLayers,
  92   // where LCD-not-allowed notifications were ignored.
  93   settings.layers_always_allowed_lcd_text = true;
  94   settings.renderer_settings.refresh_rate =
  95       context_factory_->DoesCreateTestContexts() ? kTestRefreshRate
  96                                                  : kDefaultRefreshRate;
  97   settings.main_frame_before_activation_enabled = false;
  98   settings.throttle_frame_production =
  99       !command_line->HasSwitch(switches::kDisableGpuVsync);
 100 #if !defined(OS_MACOSX)
 101   settings.renderer_settings.partial_swap_enabled =
 102       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
 103 #endif
 104 #if defined(OS_CHROMEOS)
 105   settings.per_tile_painting_enabled = true;
 106 #endif
 107 #if defined(OS_WIN)
 108   settings.disable_hi_res_timer_tasks_on_battery =
 109       !context_factory_->DoesCreateTestContexts();
 110   settings.renderer_settings.finish_rendering_on_resize = true;
 111 #endif
 112
 113   // These flags should be mirrored by renderer versions in content/renderer/.
 114   settings.initial_debug_state.show_debug_borders =
 115       command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
 116   settings.initial_debug_state.show_fps_counter =
 117       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
 118   settings.initial_debug_state.show_layer_animation_bounds_rects =
 119       command_line->HasSwitch(cc::switches::kUIShowLayerAnimationBounds);
 120   settings.initial_debug_state.show_paint_rects =
 121       command_line->HasSwitch(switches::kUIShowPaintRects);
 122   settings.initial_debug_state.show_property_changed_rects =
 123       command_line->HasSwitch(cc::switches::kUIShowPropertyChangedRects);
 124   settings.initial_debug_state.show_surface_damage_rects =
 125       command_line->HasSwitch(cc::switches::kUIShowSurfaceDamageRects);
 126   settings.initial_debug_state.show_screen_space_rects =
 127       command_line->HasSwitch(cc::switches::kUIShowScreenSpaceRects);
 128   settings.initial_debug_state.show_replica_screen_space_rects =
 129       command_line->HasSwitch(cc::switches::kUIShowReplicaScreenSpaceRects);
 130   settings.initial_debug_state.show_occluding_rects =
 131       command_line->HasSwitch(cc::switches::kUIShowOccludingRects);
 132   settings.initial_debug_state.show_non_occluding_rects =
 133       command_line->HasSwitch(cc::switches::kUIShowNonOccludingRects);
 134
 135   settings.initial_debug_state.SetRecordRenderingStats(
 136       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 137
 138   settings.impl_side_painting = IsUIImplSidePaintingEnabled();
 139   settings.use_zero_copy = IsUIZeroCopyEnabled();
 140
 141   base::TimeTicks before_create = base::TimeTicks::Now();
 142   if (compositor_thread_loop_.get()) {
 143     host_ = cc::LayerTreeHost::CreateThreaded(
 144         this,
 145         context_factory_->GetSharedBitmapManager(),
 146         context_factory_->GetGpuMemoryBufferManager(),
 147         settings,
 148         task_runner_,
 149         compositor_thread_loop_,
 150         nullptr);
 151   } else {
 152     host_ = cc::LayerTreeHost::CreateSingleThreaded(
 153         this,
 154         this,
 155         context_factory_->GetSharedBitmapManager(),
 156         context_factory_->GetGpuMemoryBufferManager(),
 157         settings,
 158         task_runner_,
 159         nullptr);
 160   }
 161   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
 162                       base::TimeTicks::Now() - before_create);
 163   host_->SetRootLayer(root_web_layer_);
 164   host_->set_surface_id_namespace(surface_id_allocator_->id_namespace());
 165   host_->SetLayerTreeHostClientReady();
 166 }
 167
 168 Compositor::~Compositor() {
 169   TRACE_EVENT0("shutdown", "Compositor::destructor");
 170
 171   CancelCompositorLock();
 172   DCHECK(!compositor_lock_);
 173
 174   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
 175                     OnCompositingShuttingDown(this));
 176
 177   if (root_layer_)
 178     root_layer_->SetCompositor(NULL);
 179
 180   // Stop all outstanding draws before telling the ContextFactory to tear
 181   // down any contexts that the |host_| may rely upon.
 182   host_.reset();
 183
 184   context_factory_->RemoveCompositor(this);
 185 }
 186
 187 void Compositor::SetOutputSurface(
 188     scoped_ptr<cc::OutputSurface> output_surface) {
 189   host_->SetOutputSurface(output_surface.Pass());
 190 }
 191
 192 void Compositor::ScheduleDraw() {
 193   host_->SetNeedsCommit();
 194 }
 195
 196 void Compositor::SetRootLayer(Layer* root_layer) {
 197   if (root_layer_ == root_layer)
 198     return;
 199   if (root_layer_)
 200     root_layer_->SetCompositor(NULL);
 201   root_layer_ = root_layer;
 202   if (root_layer_ && !root_layer_->GetCompositor())
 203     root_layer_->SetCompositor(this);
 204   root_web_layer_->RemoveAllChildren();
 205   if (root_layer_)
 206     root_web_layer_->AddChild(root_layer_->cc_layer());
 207 }
 208
 209 void Compositor::SetHostHasTransparentBackground(
 210     bool host_has_transparent_background) {
 211   host_->set_has_transparent_background(host_has_transparent_background);
 212 }
 213
 214 void Compositor::ScheduleFullRedraw() {
 215   // TODO(enne): Some callers (mac) call this function expecting that it
 216   // will also commit.  This should probably just redraw the screen
 217   // from damage and not commit.  ScheduleDraw/ScheduleRedraw need
 218   // better names.
 219   host_->SetNeedsRedraw();
 220   host_->SetNeedsCommit();
 221 }
 222
 223 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
 224   // TODO(enne): Make this not commit.  See ScheduleFullRedraw.
 225   host_->SetNeedsRedrawRect(damage_rect);
 226   host_->SetNeedsCommit();
 227 }
 228
 229 void Compositor::DisableSwapUntilResize() {
 230   host_->FinishAllRendering();
 231   context_factory_->ResizeDisplay(this, gfx::Size());
 232 }
 233
 234 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
 235   scoped_ptr<cc::SwapPromise> swap_promise(
 236       new cc::LatencyInfoSwapPromise(latency_info));
 237   host_->QueueSwapPromise(swap_promise.Pass());
 238 }
 239
 240 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
 241   DCHECK_GT(scale, 0);
 242   if (!size_in_pixel.IsEmpty()) {
 243     size_ = size_in_pixel;
 244     host_->SetViewportSize(size_in_pixel);
 245     root_web_layer_->SetBounds(size_in_pixel);
 246     context_factory_->ResizeDisplay(this, size_in_pixel);
 247   }
 248   if (device_scale_factor_ != scale) {
 249     device_scale_factor_ = scale;
 250     host_->SetDeviceScaleFactor(scale);
 251     if (root_layer_)
 252       root_layer_->OnDeviceScaleFactorChanged(scale);
 253   }
 254 }
 255
 256 void Compositor::SetBackgroundColor(SkColor color) {
 257   host_->set_background_color(color);
 258   ScheduleDraw();
 259 }
 260
 261 void Compositor::SetVisible(bool visible) {
 262   host_->SetVisible(visible);
 263 }
 264
 265 scoped_refptr<CompositorVSyncManager> Compositor::vsync_manager() const {
 266   return vsync_manager_;
 267 }
 268
 269 void Compositor::AddObserver(CompositorObserver* observer) {
 270   observer_list_.AddObserver(observer);
 271 }
 272
 273 void Compositor::RemoveObserver(CompositorObserver* observer) {
 274   observer_list_.RemoveObserver(observer);
 275 }
 276
 277 bool Compositor::HasObserver(const CompositorObserver* observer) const {
 278   return observer_list_.HasObserver(observer);
 279 }
 280
 281 void Compositor::AddAnimationObserver(CompositorAnimationObserver* observer) {
 282   animation_observer_list_.AddObserver(observer);
 283   host_->SetNeedsAnimate();
 284 }
 285
 286 void Compositor::RemoveAnimationObserver(
 287     CompositorAnimationObserver* observer) {
 288   animation_observer_list_.RemoveObserver(observer);
 289 }
 290
 291 bool Compositor::HasAnimationObserver(
 292     const CompositorAnimationObserver* observer) const {
 293   return animation_observer_list_.HasObserver(observer);
 294 }
 295
 296 void Compositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
 297   FOR_EACH_OBSERVER(CompositorAnimationObserver,
 298                     animation_observer_list_,
 299                     OnAnimationStep(args.frame_time));
 300   if (animation_observer_list_.might_have_observers())
 301     host_->SetNeedsAnimate();
 302 }
 303
 304 void Compositor::Layout() {
 305   // We're sending damage that will be addressed during this composite
 306   // cycle, so we don't need to schedule another composite to address it.
 307   disable_schedule_composite_ = true;
 308   if (root_layer_)
 309     root_layer_->SendDamagedRects();
 310   disable_schedule_composite_ = false;
 311 }
 312
 313 void Compositor::RequestNewOutputSurface() {
 314   bool fallback =
 315       num_failed_recreate_attempts_ >= OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK;
 316   context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr(),
 317                                         fallback);
 318 }
 319
 320 void Compositor::DidInitializeOutputSurface() {
 321   num_failed_recreate_attempts_ = 0;
 322 }
 323
 324 void Compositor::DidFailToInitializeOutputSurface() {
 325   num_failed_recreate_attempts_++;
 326
 327   // Tolerate a certain number of recreation failures to work around races
 328   // in the output-surface-lost machinery.
 329   if (num_failed_recreate_attempts_ >= MAX_OUTPUT_SURFACE_RETRIES)
 330     LOG(FATAL) << "Failed to create a fallback OutputSurface.";
 331
 332   base::MessageLoop::current()->PostTask(
 333       FROM_HERE, base::Bind(&Compositor::RequestNewOutputSurface,
 334                             weak_ptr_factory_.GetWeakPtr()));
 335 }
 336
 337 void Compositor::DidCommit() {
 338   DCHECK(!IsLocked());
 339   FOR_EACH_OBSERVER(CompositorObserver,
 340                     observer_list_,
 341                     OnCompositingDidCommit(this));
 342 }
 343
 344 void Compositor::DidCommitAndDrawFrame() {
 345 }
 346
 347 void Compositor::DidCompleteSwapBuffers() {
 348   // DidPostSwapBuffers is a SingleThreadProxy-only feature.  Synthetically
 349   // generate OnCompositingStarted messages for the threaded case so that
 350   // OnCompositingStarted/OnCompositingEnded messages match.
 351   if (compositor_thread_loop_.get()) {
 352     base::TimeTicks start_time = gfx::FrameTime::Now();
 353     FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
 354                       OnCompositingStarted(this, start_time));
 355   }
 356   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
 357                     OnCompositingEnded(this));
 358 }
 359
 360 void Compositor::DidPostSwapBuffers() {
 361   base::TimeTicks start_time = gfx::FrameTime::Now();
 362   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
 363                     OnCompositingStarted(this, start_time));
 364 }
 365
 366 void Compositor::DidAbortSwapBuffers() {
 367   FOR_EACH_OBSERVER(CompositorObserver,
 368                     observer_list_,
 369                     OnCompositingAborted(this));
 370 }
 371
 372 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
 373   return host_->debug_state();
 374 }
 375
 376 void Compositor::SetLayerTreeDebugState(
 377     const cc::LayerTreeDebugState& debug_state) {
 378   host_->SetDebugState(debug_state);
 379 }
 380
 381 const cc::RendererSettings& Compositor::GetRendererSettings() const {
 382   return host_->settings().renderer_settings;
 383 }
 384
 385 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
 386   if (!compositor_lock_) {
 387     compositor_lock_ = new CompositorLock(this);
 388     host_->SetDeferCommits(true);
 389     FOR_EACH_OBSERVER(CompositorObserver,
 390                       observer_list_,
 391                       OnCompositingLockStateChanged(this));
 392   }
 393   return compositor_lock_;
 394 }
 395
 396 void Compositor::UnlockCompositor() {
 397   DCHECK(compositor_lock_);
 398   compositor_lock_ = NULL;
 399   host_->SetDeferCommits(false);
 400   FOR_EACH_OBSERVER(CompositorObserver,
 401                     observer_list_,
 402                     OnCompositingLockStateChanged(this));
 403 }
 404
 405 void Compositor::CancelCompositorLock() {
 406   if (compositor_lock_)
 407     compositor_lock_->CancelLock();
 408 }
 409
 410 }  // namespace ui