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/debug/trace_event.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "base/metrics/histogram.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/sys_info.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       disable_schedule_composite_(false),
  81       compositor_lock_(NULL),
  82       defer_draw_scheduling_(false),
  83       waiting_on_compositing_end_(false),
  84       draw_on_compositing_end_(false),
  85       swap_state_(SWAP_NONE),
  86       layer_animator_collection_(this),
  87       weak_ptr_factory_(this) {
  88   root_web_layer_ = cc::Layer::Create();
  89
  90   CommandLine* command_line = CommandLine::ForCurrentProcess();
  91
  92   cc::LayerTreeSettings settings;
  93   // When impl-side painting is enabled, this will ensure PictureLayers always
  94   // can have LCD text, to match the previous behaviour with ContentLayers,
  95   // where LCD-not-allowed notifications were ignored.
  96   settings.layers_always_allowed_lcd_text = true;
  97   settings.renderer_settings.refresh_rate =
  98       context_factory_->DoesCreateTestContexts() ? kTestRefreshRate
  99                                                  : kDefaultRefreshRate;
 100   settings.main_frame_before_activation_enabled = false;
 101   settings.throttle_frame_production =
 102       !command_line->HasSwitch(switches::kDisableGpuVsync);
 103 #if !defined(OS_MACOSX)
 104   settings.renderer_settings.partial_swap_enabled =
 105       !command_line->HasSwitch(cc::switches::kUIDisablePartialSwap);
 106 #endif
 107 #if defined(OS_CHROMEOS)
 108   settings.per_tile_painting_enabled = true;
 109 #endif
 110 #if defined(OS_WIN)
 111   settings.disable_hi_res_timer_tasks_on_battery = true;
 112 #endif
 113
 114   // These flags should be mirrored by renderer versions in content/renderer/.
 115   settings.initial_debug_state.show_debug_borders =
 116       command_line->HasSwitch(cc::switches::kUIShowCompositedLayerBorders);
 117   settings.initial_debug_state.show_fps_counter =
 118       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
 119   settings.initial_debug_state.show_layer_animation_bounds_rects =
 120       command_line->HasSwitch(cc::switches::kUIShowLayerAnimationBounds);
 121   settings.initial_debug_state.show_paint_rects =
 122       command_line->HasSwitch(switches::kUIShowPaintRects);
 123   settings.initial_debug_state.show_property_changed_rects =
 124       command_line->HasSwitch(cc::switches::kUIShowPropertyChangedRects);
 125   settings.initial_debug_state.show_surface_damage_rects =
 126       command_line->HasSwitch(cc::switches::kUIShowSurfaceDamageRects);
 127   settings.initial_debug_state.show_screen_space_rects =
 128       command_line->HasSwitch(cc::switches::kUIShowScreenSpaceRects);
 129   settings.initial_debug_state.show_replica_screen_space_rects =
 130       command_line->HasSwitch(cc::switches::kUIShowReplicaScreenSpaceRects);
 131   settings.initial_debug_state.show_occluding_rects =
 132       command_line->HasSwitch(cc::switches::kUIShowOccludingRects);
 133   settings.initial_debug_state.show_non_occluding_rects =
 134       command_line->HasSwitch(cc::switches::kUIShowNonOccludingRects);
 135
 136   settings.initial_debug_state.SetRecordRenderingStats(
 137       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
 138
 139   settings.impl_side_painting = IsUIImplSidePaintingEnabled();
 140   settings.use_zero_copy = IsUIZeroCopyEnabled();
 141   settings.single_thread_proxy_scheduler = false;
 142
 143   base::TimeTicks before_create = base::TimeTicks::Now();
 144   if (compositor_thread_loop_.get()) {
 145     host_ = cc::LayerTreeHost::CreateThreaded(
 146         this,
 147         context_factory_->GetSharedBitmapManager(),
 148         context_factory_->GetGpuMemoryBufferManager(),
 149         settings,
 150         task_runner_,
 151         compositor_thread_loop_,
 152         nullptr);
 153   } else {
 154     host_ = cc::LayerTreeHost::CreateSingleThreaded(
 155         this,
 156         this,
 157         context_factory_->GetSharedBitmapManager(),
 158         context_factory_->GetGpuMemoryBufferManager(),
 159         settings,
 160         task_runner_,
 161         nullptr);
 162   }
 163   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
 164                       base::TimeTicks::Now() - before_create);
 165   host_->SetRootLayer(root_web_layer_);
 166   host_->set_surface_id_namespace(surface_id_allocator_->id_namespace());
 167   host_->SetLayerTreeHostClientReady();
 168 }
 169
 170 Compositor::~Compositor() {
 171   TRACE_EVENT0("shutdown", "Compositor::destructor");
 172
 173   CancelCompositorLock();
 174   DCHECK(!compositor_lock_);
 175
 176   if (root_layer_)
 177     root_layer_->SetCompositor(NULL);
 178
 179   // Stop all outstanding draws before telling the ContextFactory to tear
 180   // down any contexts that the |host_| may rely upon.
 181   host_.reset();
 182
 183   context_factory_->RemoveCompositor(this);
 184 }
 185
 186 void Compositor::SetOutputSurface(
 187     scoped_ptr<cc::OutputSurface> output_surface) {
 188   host_->SetOutputSurface(output_surface.Pass());
 189 }
 190
 191 void Compositor::ScheduleDraw() {
 192   if (compositor_thread_loop_.get()) {
 193     host_->SetNeedsCommit();
 194   } else if (!defer_draw_scheduling_) {
 195     defer_draw_scheduling_ = true;
 196     task_runner_->PostTask(
 197         FROM_HERE,
 198         base::Bind(&Compositor::Draw, weak_ptr_factory_.GetWeakPtr()));
 199   }
 200 }
 201
 202 void Compositor::SetRootLayer(Layer* root_layer) {
 203   if (root_layer_ == root_layer)
 204     return;
 205   if (root_layer_)
 206     root_layer_->SetCompositor(NULL);
 207   root_layer_ = root_layer;
 208   if (root_layer_ && !root_layer_->GetCompositor())
 209     root_layer_->SetCompositor(this);
 210   root_web_layer_->RemoveAllChildren();
 211   if (root_layer_)
 212     root_web_layer_->AddChild(root_layer_->cc_layer());
 213 }
 214
 215 void Compositor::SetHostHasTransparentBackground(
 216     bool host_has_transparent_background) {
 217   host_->set_has_transparent_background(host_has_transparent_background);
 218 }
 219
 220 void Compositor::Draw() {
 221   DCHECK(!compositor_thread_loop_.get());
 222
 223   defer_draw_scheduling_ = false;
 224   if (waiting_on_compositing_end_) {
 225     draw_on_compositing_end_ = true;
 226     return;
 227   }
 228   if (!root_layer_)
 229     return;
 230
 231   TRACE_EVENT_ASYNC_BEGIN0("ui", "Compositor::Draw", last_started_frame_ + 1);
 232
 233   DCHECK_NE(swap_state_, SWAP_POSTED);
 234   swap_state_ = SWAP_NONE;
 235
 236   waiting_on_compositing_end_ = true;
 237   last_started_frame_++;
 238   if (!IsLocked()) {
 239     // TODO(nduca): Temporary while compositor calls
 240     // compositeImmediately() directly.
 241     cc::BeginFrameArgs args =
 242         cc::BeginFrameArgs::Create(gfx::FrameTime::Now(),
 243                                    base::TimeTicks(),
 244                                    cc::BeginFrameArgs::DefaultInterval());
 245     BeginMainFrame(args);
 246     host_->Composite(args.frame_time);
 247   }
 248   if (swap_state_ == SWAP_NONE)
 249     NotifyEnd();
 250 }
 251
 252 void Compositor::ScheduleFullRedraw() {
 253   host_->SetNeedsRedraw();
 254 }
 255
 256 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
 257   host_->SetNeedsRedrawRect(damage_rect);
 258 }
 259
 260 void Compositor::FinishAllRendering() {
 261   host_->FinishAllRendering();
 262 }
 263
 264 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
 265   scoped_ptr<cc::SwapPromise> swap_promise(
 266       new cc::LatencyInfoSwapPromise(latency_info));
 267   host_->QueueSwapPromise(swap_promise.Pass());
 268 }
 269
 270 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
 271   DCHECK_GT(scale, 0);
 272   if (!size_in_pixel.IsEmpty()) {
 273     size_ = size_in_pixel;
 274     host_->SetViewportSize(size_in_pixel);
 275     root_web_layer_->SetBounds(size_in_pixel);
 276   }
 277   if (device_scale_factor_ != scale) {
 278     device_scale_factor_ = scale;
 279     host_->SetDeviceScaleFactor(scale);
 280     if (root_layer_)
 281       root_layer_->OnDeviceScaleFactorChanged(scale);
 282   }
 283 }
 284
 285 void Compositor::SetBackgroundColor(SkColor color) {
 286   host_->set_background_color(color);
 287   ScheduleDraw();
 288 }
 289
 290 void Compositor::SetVisible(bool visible) {
 291   host_->SetVisible(visible);
 292 }
 293
 294 scoped_refptr<CompositorVSyncManager> Compositor::vsync_manager() const {
 295   return vsync_manager_;
 296 }
 297
 298 void Compositor::AddObserver(CompositorObserver* observer) {
 299 #if defined(OS_MACOSX)
 300   // Debugging instrumentation for crbug.com/401630.
 301   // TODO(ccameron): remove this.
 302   CHECK(observer);
 303   if (!observer_list_.HasObserver(observer))
 304     observer->observing_count_ += 1;
 305 #endif
 306
 307   observer_list_.AddObserver(observer);
 308 }
 309
 310 void Compositor::RemoveObserver(CompositorObserver* observer) {
 311 #if defined(OS_MACOSX)
 312   // Debugging instrumentation for crbug.com/401630.
 313   // TODO(ccameron): remove this.
 314   if (observer_list_.HasObserver(observer))
 315     observer->observing_count_ -= 1;
 316 #endif
 317
 318   observer_list_.RemoveObserver(observer);
 319 }
 320
 321 bool Compositor::HasObserver(const CompositorObserver* observer) const {
 322   return observer_list_.HasObserver(observer);
 323 }
 324
 325 void Compositor::AddAnimationObserver(CompositorAnimationObserver* observer) {
 326   animation_observer_list_.AddObserver(observer);
 327   host_->SetNeedsAnimate();
 328 }
 329
 330 void Compositor::RemoveAnimationObserver(
 331     CompositorAnimationObserver* observer) {
 332   animation_observer_list_.RemoveObserver(observer);
 333 }
 334
 335 bool Compositor::HasAnimationObserver(
 336     const CompositorAnimationObserver* observer) const {
 337   return animation_observer_list_.HasObserver(observer);
 338 }
 339
 340 void Compositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
 341   FOR_EACH_OBSERVER(CompositorAnimationObserver,
 342                     animation_observer_list_,
 343                     OnAnimationStep(args.frame_time));
 344   if (animation_observer_list_.might_have_observers())
 345     host_->SetNeedsAnimate();
 346 }
 347
 348 void Compositor::Layout() {
 349   // We're sending damage that will be addressed during this composite
 350   // cycle, so we don't need to schedule another composite to address it.
 351   disable_schedule_composite_ = true;
 352   if (root_layer_)
 353     root_layer_->SendDamagedRects();
 354   disable_schedule_composite_ = false;
 355 }
 356
 357 void Compositor::RequestNewOutputSurface(bool fallback) {
 358   context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr(),
 359                                         fallback);
 360 }
 361
 362 void Compositor::DidCommit() {
 363   DCHECK(!IsLocked());
 364   FOR_EACH_OBSERVER(CompositorObserver,
 365                     observer_list_,
 366                     OnCompositingDidCommit(this));
 367 }
 368
 369 void Compositor::DidCommitAndDrawFrame() {
 370   base::TimeTicks start_time = gfx::FrameTime::Now();
 371   FOR_EACH_OBSERVER(CompositorObserver,
 372                     observer_list_,
 373                     OnCompositingStarted(this, start_time));
 374 }
 375
 376 void Compositor::DidCompleteSwapBuffers() {
 377   if (compositor_thread_loop_.get()) {
 378     NotifyEnd();
 379   } else {
 380     DCHECK_EQ(swap_state_, SWAP_POSTED);
 381     NotifyEnd();
 382     swap_state_ = SWAP_COMPLETED;
 383   }
 384 }
 385
 386 void Compositor::ScheduleComposite() {
 387   if (!disable_schedule_composite_)
 388     ScheduleDraw();
 389 }
 390
 391 void Compositor::ScheduleAnimation() {
 392   ScheduleComposite();
 393 }
 394
 395 void Compositor::DidPostSwapBuffers() {
 396   DCHECK(!compositor_thread_loop_.get());
 397   DCHECK_EQ(swap_state_, SWAP_NONE);
 398   swap_state_ = SWAP_POSTED;
 399 }
 400
 401 void Compositor::DidAbortSwapBuffers() {
 402   if (!compositor_thread_loop_.get()) {
 403     if (swap_state_ == SWAP_POSTED) {
 404       NotifyEnd();
 405       swap_state_ = SWAP_COMPLETED;
 406     }
 407   }
 408
 409   FOR_EACH_OBSERVER(CompositorObserver,
 410                     observer_list_,
 411                     OnCompositingAborted(this));
 412 }
 413
 414 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
 415   return host_->debug_state();
 416 }
 417
 418 void Compositor::SetLayerTreeDebugState(
 419     const cc::LayerTreeDebugState& debug_state) {
 420   host_->SetDebugState(debug_state);
 421 }
 422
 423 const cc::RendererSettings& Compositor::GetRendererSettings() const {
 424   return host_->settings().renderer_settings;
 425 }
 426
 427 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
 428   if (!compositor_lock_) {
 429     compositor_lock_ = new CompositorLock(this);
 430     if (compositor_thread_loop_.get())
 431       host_->SetDeferCommits(true);
 432     FOR_EACH_OBSERVER(CompositorObserver,
 433                       observer_list_,
 434                       OnCompositingLockStateChanged(this));
 435   }
 436   return compositor_lock_;
 437 }
 438
 439 void Compositor::UnlockCompositor() {
 440   DCHECK(compositor_lock_);
 441   compositor_lock_ = NULL;
 442   if (compositor_thread_loop_.get())
 443     host_->SetDeferCommits(false);
 444   FOR_EACH_OBSERVER(CompositorObserver,
 445                     observer_list_,
 446                     OnCompositingLockStateChanged(this));
 447 }
 448
 449 void Compositor::CancelCompositorLock() {
 450   if (compositor_lock_)
 451     compositor_lock_->CancelLock();
 452 }
 453
 454 void Compositor::NotifyEnd() {
 455   last_ended_frame_++;
 456   TRACE_EVENT_ASYNC_END0("ui", "Compositor::Draw", last_ended_frame_);
 457   waiting_on_compositing_end_ = false;
 458   if (draw_on_compositing_end_) {
 459     draw_on_compositing_end_ = false;
 460
 461     // Call ScheduleDraw() instead of Draw() in order to allow other
 462     // CompositorObservers to be notified before starting another
 463     // draw cycle.
 464     ScheduleDraw();
 465   }
 466   FOR_EACH_OBSERVER(
 467       CompositorObserver, observer_list_, OnCompositingEnded(this));
 468 }
 469
 470 }  // namespace ui